{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install griffe requests matplotlib networkx -q\n",
        "\n",
        "import griffe\n",
        "import json\n",
        "import requests\n",
        "from typing import Dict, List, Any\n",
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "from collections import defaultdict\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "metadata": {
        "id": "P3f6_QJbqlrA"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class AICodeAnalyzer:\n",
        "    \"\"\"AI Agent for advanced code analysis using Griffe\"\"\"\n",
        "\n",
        "    def __init__(self):\n",
        "        self.analysis_cache = {}\n",
        "        self.dependency_graph = nx.DiGraph()\n",
        "\n",
        "    def analyze_package(self, package_name: str, search_paths: List[str] = None) -> Dict[str, Any]:\n",
        "        \"\"\"Comprehensive package analysis for AI decision making\"\"\"\n",
        "        try:\n",
        "            pkg = griffe.load(package_name, search_paths=search_paths, try_relative_path=False)\n",
        "\n",
        "            analysis = {\n",
        "                'package_name': package_name,\n",
        "                'total_modules': 0,\n",
        "                'total_classes': 0,\n",
        "                'total_functions': 0,\n",
        "                'complexity_score': 0,\n",
        "                'api_surface': [],\n",
        "                'inheritance_tree': {},\n",
        "                'risk_factors': []\n",
        "            }\n",
        "\n",
        "            self._analyze_object(pkg, analysis)\n",
        "\n",
        "            analysis['complexity_score'] = self._calculate_complexity(analysis)\n",
        "\n",
        "            analysis['risk_factors'] = self._identify_risks(pkg, analysis)\n",
        "\n",
        "            self.analysis_cache[package_name] = analysis\n",
        "            return analysis\n",
        "\n",
        "        except Exception as e:\n",
        "            return {'error': f\"Failed to analyze {package_name}: {str(e)}\"}\n",
        "\n",
        "    def analyze_simple_module(self, module_name: str) -> Dict[str, Any]:\n",
        "        \"\"\"Analyze a simple module without deep dependency resolution\"\"\"\n",
        "        try:\n",
        "            import importlib\n",
        "            module = importlib.import_module(module_name)\n",
        "\n",
        "            analysis = {\n",
        "                'package_name': module_name,\n",
        "                'total_modules': 1,\n",
        "                'total_classes': 0,\n",
        "                'total_functions': 0,\n",
        "                'complexity_score': 0,\n",
        "                'api_surface': [],\n",
        "                'inheritance_tree': {},\n",
        "                'risk_factors': []\n",
        "            }\n",
        "\n",
        "            for attr_name in dir(module):\n",
        "                if not attr_name.startswith('_'):\n",
        "                    attr = getattr(module, attr_name)\n",
        "                    if isinstance(attr, type):\n",
        "                        analysis['total_classes'] += 1\n",
        "                        analysis['api_surface'].append({\n",
        "                            'name': f\"{module_name}.{attr_name}\",\n",
        "                            'type': 'class',\n",
        "                            'public': True,\n",
        "                            'docstring': bool(attr.__doc__),\n",
        "                            'methods': len([m for m in dir(attr) if not m.startswith('_')])\n",
        "                        })\n",
        "                    elif callable(attr):\n",
        "                        analysis['total_functions'] += 1\n",
        "                        analysis['api_surface'].append({\n",
        "                            'name': f\"{module_name}.{attr_name}\",\n",
        "                            'type': 'function',\n",
        "                            'public': True,\n",
        "                            'docstring': bool(attr.__doc__),\n",
        "                            'parameters': 0\n",
        "                        })\n",
        "\n",
        "            analysis['complexity_score'] = self._calculate_complexity(analysis)\n",
        "\n",
        "            analysis['risk_factors'] = self._identify_basic_risks(analysis)\n",
        "\n",
        "            self.analysis_cache[module_name] = analysis\n",
        "            return analysis\n",
        "\n",
        "        except Exception as e:\n",
        "            return {'error': f\"Failed to analyze {module_name}: {str(e)}\"}\n",
        "\n",
        "    def _analyze_object(self, obj, analysis: Dict[str, Any], path: str = \"\"):\n",
        "        \"\"\"Recursively analyze package objects\"\"\"\n",
        "        try:\n",
        "            current_path = f\"{path}.{obj.name}\" if path else obj.name\n",
        "\n",
        "            if hasattr(obj, 'kind'):\n",
        "                if obj.kind.value == 'module':\n",
        "                    analysis['total_modules'] += 1\n",
        "                elif obj.kind.value == 'class':\n",
        "                    analysis['total_classes'] += 1\n",
        "                    analysis['api_surface'].append({\n",
        "                        'name': current_path,\n",
        "                        'type': 'class',\n",
        "                        'public': not obj.name.startswith('_'),\n",
        "                        'docstring': bool(obj.docstring),\n",
        "                        'methods': len([m for m in obj.members.values() if hasattr(m, 'kind') and m.kind.value == 'function'])\n",
        "                    })\n",
        "\n",
        "                    if hasattr(obj, 'bases') and obj.bases:\n",
        "                        analysis['inheritance_tree'][current_path] = [str(base) for base in obj.bases]\n",
        "\n",
        "                elif obj.kind.value == 'function':\n",
        "                    analysis['total_functions'] += 1\n",
        "                    analysis['api_surface'].append({\n",
        "                        'name': current_path,\n",
        "                        'type': 'function',\n",
        "                        'public': not obj.name.startswith('_'),\n",
        "                        'docstring': bool(obj.docstring),\n",
        "                        'parameters': len(obj.parameters) if hasattr(obj, 'parameters') else 0\n",
        "                    })\n",
        "\n",
        "            if hasattr(obj, 'members'):\n",
        "                for member in obj.members.values():\n",
        "                    self._analyze_object(member, analysis, current_path)\n",
        "\n",
        "        except Exception as e:\n",
        "            pass\n",
        "\n",
        "    def _calculate_complexity(self, analysis: Dict[str, Any]) -> float:\n",
        "        \"\"\"Calculate package complexity score for AI decision making\"\"\"\n",
        "        base_score = (analysis['total_classes'] * 2 +\n",
        "                     analysis['total_functions'] * 1 +\n",
        "                     analysis['total_modules'] * 0.5)\n",
        "\n",
        "        inheritance_penalty = len(analysis['inheritance_tree']) * 1.5\n",
        "\n",
        "        documented_items = sum(1 for item in analysis['api_surface'] if item['docstring'])\n",
        "        total_items = len(analysis['api_surface'])\n",
        "        doc_penalty = (total_items - documented_items) * 0.3 if total_items > 0 else 0\n",
        "\n",
        "        return base_score + inheritance_penalty + doc_penalty\n",
        "\n",
        "    def _identify_risks(self, pkg, analysis: Dict[str, Any]) -> List[str]:\n",
        "        \"\"\"Identify potential risks for AI agent decision making\"\"\"\n",
        "        risks = []\n",
        "\n",
        "        if len(analysis['api_surface']) > 50:\n",
        "            risks.append(\"Large API surface - potential maintenance burden\")\n",
        "\n",
        "        documented = sum(1 for item in analysis['api_surface'] if item['docstring'])\n",
        "        total = len(analysis['api_surface'])\n",
        "        if total > 0 and documented / total < 0.5:\n",
        "            risks.append(\"Poor documentation coverage\")\n",
        "\n",
        "        max_inheritance_depth = 0\n",
        "        for bases in analysis['inheritance_tree'].values():\n",
        "            max_inheritance_depth = max(max_inheritance_depth, len(bases))\n",
        "        if max_inheritance_depth > 3:\n",
        "            risks.append(\"Deep inheritance hierarchy detected\")\n",
        "\n",
        "        return risks\n",
        "\n",
        "    def _identify_basic_risks(self, analysis: Dict[str, Any]) -> List[str]:\n",
        "        \"\"\"Basic risk identification for simple module analysis\"\"\"\n",
        "        risks = []\n",
        "\n",
        "        if len(analysis['api_surface']) > 30:\n",
        "            risks.append(\"Large API surface\")\n",
        "\n",
        "        documented = sum(1 for item in analysis['api_surface'] if item['docstring'])\n",
        "        total = len(analysis['api_surface'])\n",
        "        if total > 0 and documented / total < 0.4:\n",
        "            risks.append(\"Limited documentation\")\n",
        "\n",
        "        return risks\n",
        "\n",
        "    def compare_packages(self, pkg1: str, pkg2: str) -> Dict[str, Any]:\n",
        "        \"\"\"Compare two packages for AI decision making\"\"\"\n",
        "        analysis1 = self.analyze_package(pkg1)\n",
        "        if 'error' in analysis1:\n",
        "            analysis1 = self.analyze_simple_module(pkg1)\n",
        "\n",
        "        analysis2 = self.analyze_package(pkg2)\n",
        "        if 'error' in analysis2:\n",
        "            analysis2 = self.analyze_simple_module(pkg2)\n",
        "\n",
        "        if 'error' in analysis1 or 'error' in analysis2:\n",
        "            return {'error': 'Failed to compare packages'}\n",
        "\n",
        "        comparison = {\n",
        "            'package_comparison': {\n",
        "                'complexity': {\n",
        "                    pkg1: analysis1['complexity_score'],\n",
        "                    pkg2: analysis2['complexity_score'],\n",
        "                    'winner': pkg1 if analysis1['complexity_score'] < analysis2['complexity_score'] else pkg2\n",
        "                },\n",
        "                'api_size': {\n",
        "                    pkg1: len(analysis1['api_surface']),\n",
        "                    pkg2: len(analysis2['api_surface']),\n",
        "                    'winner': pkg1 if len(analysis1['api_surface']) < len(analysis2['api_surface']) else pkg2\n",
        "                },\n",
        "                'documentation': {\n",
        "                    pkg1: self._doc_coverage(analysis1),\n",
        "                    pkg2: self._doc_coverage(analysis2),\n",
        "                    'winner': pkg1 if self._doc_coverage(analysis1) > self._doc_coverage(analysis2) else pkg2\n",
        "                }\n",
        "            },\n",
        "            'recommendation': self._make_recommendation(analysis1, analysis2, pkg1, pkg2)\n",
        "        }\n",
        "\n",
        "        return comparison\n",
        "\n",
        "    def _doc_coverage(self, analysis: Dict[str, Any]) -> float:\n",
        "        \"\"\"Calculate documentation coverage percentage\"\"\"\n",
        "        if not analysis['api_surface']:\n",
        "            return 0.0\n",
        "        documented = sum(1 for item in analysis['api_surface'] if item['docstring'])\n",
        "        return (documented / len(analysis['api_surface'])) * 100\n",
        "\n",
        "    def _make_recommendation(self, a1: Dict, a2: Dict, pkg1: str, pkg2: str) -> str:\n",
        "        \"\"\"Make AI recommendation based on analysis\"\"\"\n",
        "        score1 = (100 - a1['complexity_score']) + self._doc_coverage(a1)\n",
        "        score2 = (100 - a2['complexity_score']) + self._doc_coverage(a2)\n",
        "\n",
        "        if score1 > score2:\n",
        "            return f\"Recommend {pkg1}: Better complexity/documentation balance\"\n",
        "        elif score2 > score1:\n",
        "            return f\"Recommend {pkg2}: Better complexity/documentation balance\"\n",
        "        else:\n",
        "            return \"Packages are equivalent in key metrics\"\n",
        "\n",
        "    def visualize_analysis(self, package_name: str):\n",
        "        \"\"\"Create visualizations for AI insights\"\"\"\n",
        "        if package_name not in self.analysis_cache:\n",
        "            analysis = self.analyze_package(package_name)\n",
        "            if 'error' in analysis:\n",
        "                analysis = self.analyze_simple_module(package_name)\n",
        "\n",
        "        analysis = self.analysis_cache[package_name]\n",
        "\n",
        "        if 'error' in analysis:\n",
        "            print(f\"❌ Cannot visualize {package_name}: {analysis['error']}\")\n",
        "            return\n",
        "\n",
        "        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))\n",
        "        fig.suptitle(f'AI Analysis Dashboard: {package_name}', fontsize=16, fontweight='bold')\n",
        "\n",
        "        components = ['Modules', 'Classes', 'Functions']\n",
        "        counts = [analysis['total_modules'], analysis['total_classes'], analysis['total_functions']]\n",
        "        colors = ['#FF6B6B', '#4ECDC4', '#45B7D1']\n",
        "\n",
        "        non_zero_components = []\n",
        "        non_zero_counts = []\n",
        "        non_zero_colors = []\n",
        "        for i, count in enumerate(counts):\n",
        "            if count > 0:\n",
        "                non_zero_components.append(components[i])\n",
        "                non_zero_counts.append(count)\n",
        "                non_zero_colors.append(colors[i])\n",
        "\n",
        "        if non_zero_counts:\n",
        "            ax1.pie(non_zero_counts, labels=non_zero_components, colors=non_zero_colors,\n",
        "                   autopct='%1.1f%%', startangle=90)\n",
        "        else:\n",
        "            ax1.text(0.5, 0.5, 'No components found', ha='center', va='center', transform=ax1.transAxes)\n",
        "        ax1.set_title('Component Distribution')\n",
        "\n",
        "        public_items = sum(1 for item in analysis['api_surface'] if item['public'])\n",
        "        private_items = len(analysis['api_surface']) - public_items\n",
        "\n",
        "        ax2.bar(['Public API', 'Private API'], [public_items, private_items],\n",
        "                color=['#2ECC71', '#E74C3C'])\n",
        "        ax2.set_title('API Surface Analysis')\n",
        "        ax2.set_ylabel('Count')\n",
        "\n",
        "        documented = sum(1 for item in analysis['api_surface'] if item['docstring'])\n",
        "        undocumented = len(analysis['api_surface']) - documented\n",
        "\n",
        "        ax3.bar(['Documented', 'Undocumented'], [documented, undocumented],\n",
        "                color=['#3498DB', '#F39C12'])\n",
        "        ax3.set_title('Documentation Coverage')\n",
        "        ax3.set_ylabel('Count')\n",
        "\n",
        "        complexity = analysis['complexity_score']\n",
        "        ax4.barh(['Complexity Score'], [complexity], color='#9B59B6')\n",
        "        ax4.set_title('Package Complexity')\n",
        "        ax4.set_xlabel('Score')\n",
        "\n",
        "        plt.tight_layout()\n",
        "        plt.show()\n",
        "\n",
        "        print(f\"\\n🤖 AI INSIGHTS for {package_name}:\")\n",
        "        print(f\"📊 Complexity Score: {complexity:.2f}\")\n",
        "        print(f\"📈 Total API Elements: {len(analysis['api_surface'])}\")\n",
        "        print(f\"📚 Documentation Coverage: {self._doc_coverage(analysis):.1f}%\")\n",
        "\n",
        "        if analysis['risk_factors']:\n",
        "            print(f\"⚠️  Risk Factors:\")\n",
        "            for risk in analysis['risk_factors']:\n",
        "                print(f\"   • {risk}\")\n",
        "        else:\n",
        "            print(\"✅ No major risk factors detected\")"
      ],
      "metadata": {
        "id": "LfIACpZsqq2V"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def main():\n",
        "    \"\"\"Main demonstration of AI Agent capabilities\"\"\"\n",
        "    print(\"🚀 Advanced Griffe AI Agent Tutorial - Fixed Version\")\n",
        "    print(\"===================================================\")\n",
        "\n",
        "    analyzer = AICodeAnalyzer()\n",
        "\n",
        "    packages_to_analyze = ['datetime', 'os', 'sys']\n",
        "\n",
        "    print(\"\\n🔍 Analyzing Python modules...\")\n",
        "\n",
        "    successful_analysis = None\n",
        "    for pkg in packages_to_analyze:\n",
        "        print(f\"\\n📦 Analyzing {pkg}...\")\n",
        "\n",
        "        analysis = analyzer.analyze_package(pkg)\n",
        "        if 'error' in analysis:\n",
        "            print(f\"   ⚠️  Griffe analysis failed, trying simple analysis...\")\n",
        "            analysis = analyzer.analyze_simple_module(pkg)\n",
        "\n",
        "        if 'error' not in analysis:\n",
        "            print(f\"   ✅ Modules: {analysis['total_modules']}\")\n",
        "            print(f\"   ✅ Classes: {analysis['total_classes']}\")\n",
        "            print(f\"   ✅ Functions: {analysis['total_functions']}\")\n",
        "            print(f\"   ✅ Complexity: {analysis['complexity_score']:.2f}\")\n",
        "\n",
        "            if successful_analysis is None:\n",
        "                successful_analysis = pkg\n",
        "        else:\n",
        "            print(f\"   ❌ {analysis['error']}\")\n",
        "\n",
        "    if successful_analysis:\n",
        "        print(f\"\\n📊 Generating visualization for {successful_analysis}...\")\n",
        "        analyzer.visualize_analysis(successful_analysis)\n",
        "\n",
        "    print(f\"\\n⚖️  Comparing packages...\")\n",
        "    try:\n",
        "        comparison = analyzer.compare_packages('datetime', 'os')\n",
        "        if 'error' not in comparison:\n",
        "            print(f\"🎯 {comparison['recommendation']}\")\n",
        "            print(f\"📊 Complexity comparison:\")\n",
        "            print(f\"   • datetime: {comparison['package_comparison']['complexity']['datetime']:.2f}\")\n",
        "            print(f\"   • os: {comparison['package_comparison']['complexity']['os']:.2f}\")\n",
        "        else:\n",
        "            print(f\"❌ {comparison['error']}\")\n",
        "    except Exception as e:\n",
        "        print(f\"❌ Comparison failed: {str(e)}\")\n",
        "\n",
        "    print(\"\\n🎉 Tutorial completed! This framework now:\")\n",
        "    print(\"   • Handles analysis errors gracefully\")\n",
        "    print(\"   • Falls back to simple module analysis when needed\")\n",
        "    print(\"   • Provides meaningful insights for development decisions\")\n",
        "    print(\"   • Works with both Griffe and basic Python introspection\")\n",
        "    print(\"\\n💡 For better results, try analyzing third-party packages like:\")\n",
        "    print(\"   • requests, numpy, pandas, flask, django\")"
      ],
      "metadata": {
        "id": "HjMccojLqtkJ"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "XBl4k2-9liX2",
        "outputId": "15d9b833-fdcb-437e-bfd0-b6004327ed2c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "🚀 Advanced Griffe AI Agent Tutorial - Fixed Version\n",
            "===================================================\n",
            "\n",
            "🔍 Analyzing Python modules...\n",
            "\n",
            "📦 Analyzing datetime...\n",
            "   ✅ Modules: 1\n",
            "   ✅ Classes: 7\n",
            "   ✅ Functions: 161\n",
            "   ✅ Complexity: 208.20\n",
            "\n",
            "📦 Analyzing os...\n",
            "   ✅ Modules: 1\n",
            "   ✅ Classes: 4\n",
            "   ✅ Functions: 61\n",
            "   ✅ Complexity: 84.20\n",
            "\n",
            "📦 Analyzing sys...\n",
            "   ✅ Modules: 1\n",
            "   ✅ Classes: 0\n",
            "   ✅ Functions: 41\n",
            "   ✅ Complexity: 41.80\n",
            "\n",
            "📊 Generating visualization for datetime...\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1000 with 4 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABdEAAAPZCAYAAAD+1mNdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA/LRJREFUeJzs3Xd4U+X///FX0qaD0gUtLYVSyt4gKBsRQVARHDjwgwoOXIAL3CI4caMigvhRRMUPCoKKCg6WIohsRIaMlt0ySnebtMn5/cGX/AhtoYWmp+P5uK5cF+e+73PO+yRpSN65874thmEYAgAAAAAAAAAABVjNDgAAAAAAAAAAgPKKJDoAAAAAAAAAAEUgiQ4AAAAAAAAAQBFIogMAAAAAAAAAUASS6AAAAAAAAAAAFIEkOgAAAAAAAAAARSCJDgAAAAAAAABAEUiiAwAAAAAAAABQBJLoAAAAAAAAAAAUgSQ6AAAwxZEjR+Tn5yeLxeJx+/7778+43yWXXOIx/pNPPjnnGPLy8lSrVq0CMbz33nvnfExvq1+/vkesZho/fnypPRbFdfrjb7FYZLPZFBwcrNjYWHXu3Fl33nmn5s6dq/z8fK/HU1xLly71iHnYsGEl2v+TTz7x2H/8+PFeibO8M/v5X5Ueh6p0rQAAAGdDEh0AAJji888/V15eXoH2skjEnvT999/ryJEjpsaA85efn6/MzEzt379fq1at0scff6xBgwYpPj5eCxcuNDs8oFjKKmk9bNgwj/MsXbrUK+cBAACoTHzNDgAAAFRNM2bMKLR9/vz5SklJUY0aNbweQ1HJ8rVr12rz5s1q1aqV12OoyFq0aKFBgwa5t+vXr1/mMVx44YWKi4tTZmamdu7cqV27drn79u/fryuvvFKTJk3SiBEjyjw2oCKrX7++x993ixYtTIwGAADAXCTRAQBAmVu/fr02btzo3rbZbO5Z6Q6HQ1988YVGjhzp1RiOHDmiBQsWFBqDdCLB/sYbb3g1horuxhtv1I033mhqDCNGjPAojbJhwwbde++9WrVqlSTJMAw98MADatWqlXr27GlSlEDFc8kll+iSSy4xOwwAAIBygXIuAACgzJ0+A/z0sgVlUU7l9HIyjz32mKpVq+benjlzZpE1tU+vy52YmKjFixerf//+qlGjhgICAtSyZUtNnDhRhmEU2P/777/XiBEj1L17d9WvX1+hoaGy2WwKDw9Xhw4dNHr0aO3evbtE13P33Xd7xPTLL78UGHP48GHZbDb3mIsuusjdl5WVpTfeeEMXX3yxatWqJT8/P1WvXl1xcXHq0aOHHn744QL16s9WE/3YsWMaP368OnXqpBo1ashmsykkJEQNGjRQ79699fjjj+u3334r0XWeTbt27bRkyRKPXxG4XC49/vjjHuMSExM1duxYDRgwQE2bNvW45oYNG+rGG288Y33+WbNmacCAAYqNjVVAQID8/f0VExOjDh066K677tLUqVPldDrPGGt2draef/55NW/eXAEBAYqIiND111+vbdu2Fetajxw5olGjRikuLk7+/v6KjY3VqFGjCi1RdNK2bdv04IMPqm3btgoNDZWfn59q1aqlSy+9VO+8844yMzML3W/SpEkaOnSo2rdvr7p16yooKEj+/v6KiopSz5499dprrykjI6PAfomJiR7PkUsuuUSZmZl6+umn1bRpUwUEBBT4BcOKFSt05ZVXKjw8XEFBQerQoYOmTZtW6N/S6UqjVEl2drbGjx+vJk2ayN/fX9HR0brtttuK9Te5fPlyPfzww+rVq5caNmyo8PBw+fr6KjQ0VK1bt9Z9993n8QWi9P/LuNx+++0e7c8999wZy7vk5ORo6tSp6tevn6Kjo+Xn56fQ0FBdeOGFeu6553Ts2LFC75vTfwXUq1evQu+zs5WXKex18PPPP1enTp0UFBSkyMhI/ec//3Hfbw6HQy+//LKaNWumgIAA1a5dW3fccYcOHTpU5P25a9cujRkzRhdccIHCwsLk5+en6OhoXXXVVZozZ06xnhMAAAClwgAAAChDDofDiIiIMCQZkoygoCAjKyvL6NSpk7tNkvH3338Xun/Pnj09xk2fPv2c4mjTpo3HcRISEoybbrrJo23+/PnFiuG2227z2D719uCDDxbYv3///kWOP3kLDAw0FixYUGDfuLg4j3Enbdu2zbBYLO72gQMHFtj3nXfe8dj3v//9r2EYhpGbm2t06NDhrDF16NDB43jjxo0r8rE4cuRIgVgLuw0aNKg4D1eR931Rj/+8efMKnGvXrl3u/tmzZ581NknGHXfcUeDYI0aMKNa+GRkZ7n2WLFni0XfZZZcZLVq0KHS/sLAwIyEhweOc06dP9xgzZMgQIyYmptD969WrV2B/wzCMN954w/D19T1jzPXr1zc2bNhQYN+goKCzXm9cXJyxd+9ej/0SEhI8xrRt29Zo3bp1gf1O+uyzzwwfH59Cj3/TTTcZdevWLfT5f9LQoUM9+pcsWVLo86MoaWlpxoUXXljo+YODg4177rnHo23cuHEe+xfnueHj42N89NFHRT62Rd1OPdeWLVuMJk2anHF8dHS0sWLFiiLvm6JuJ++z0+M6/VpP/1u85pprCj1ezZo1jW3bthldu3YttL9BgwZGampqgcdi8uTJhp+f3xljveKKK4ysrKwSPcYAAADngnIuAACgTM2fP19Hjx51bw8cOFDVqlXTzTff7C7BIXm3nMq6deu0adMm93aXLl1Uv3593Xzzzfryyy89YrjqqqvOerxPP/1U1atXV8eOHbV3717t3LnT3Tdp0iSNHj1asbGxHvvYbDY1a9ZMNWvWVGhoqHJzc/Xvv/8qISFB0olZprfffrsSEhIUEBBw1hiaNm2qgQMH6ttvv5V0Yrb7nj17FBcX5x7z+eefu/8dGhqqm2++WZI0d+5crV271t0XFRWl9u3bS5IOHDighISEQmcZn8mHH36oPXv2uLfr16+vVq1ayW63u4+Zk5NTomOWRN++feXj4+MxG3z58uVq0KCBx7h69eqpTp06Cg8Pl9VqVXJysjZs2OD+lcLHH3+sAQMG6JprrpEkHTx4UO+//757/6CgIPfM20OHDmnv3r06fPjwWeM7+UuBZs2aKSYmRitWrFBubq4kKTU1VS+//LKmTZtW5P4zZ86U1WpVx44dFRAQoFWrVslut0uS9u7dq1tuuUXLly93j//88881ZswYj2M0b95cdevW1bp169yzlhMTE3X55Zdr8+bNqlmzpsf44OBgNWnSxD1DPCMjQxs3bnTvu2fPHo0aNUrffPNNkXGfnIUdFham9u3byzAMJScnS5J27typ4cOHezxmtWrVUrt27bRjxw6Pv01vGT16tNasWePetlgsuvDCCxUYGKi//vpLH3zwwVmPYbVa1aRJE0VGRio8PFx5eXlKTEzU1q1bJUlOp1MjRozQFVdcodq1a7trj+/Zs8fj3M2bN/eoQ37y38ePH1ffvn21f/9+d1+jRo3UtGlTJScnu4+RlJSkAQMGaNOmTYqJidFFF12kzMxMrVmzxuNv8+KLL1ZkZKR7+9R/l8Q333yjyMhIXXDBBVq7dq37eXHs2DG1b99e2dnZio2NVbNmzfTHH38oOztbkrR79269//77evLJJ93Hmj17tsc6Bj4+PurUqZPCw8O1YcMGHThwQJK0YMEC3XHHHZo1a9Y5xQwAAFBsZmfxAQBA1TJgwACPmYQnZ3sfOnTIsFqtHrMo8/LyCuxfGjPRR40a5XGMSZMmGYZhGHa73QgLC3O3+/n5GceOHTtrDHFxcUZiYqJhGIaRl5dn9O7d26N/xowZHvtv2bKlyNmTY8aM8dj39NnoRc1ENwzDWL58uUff448/7u77999/PfpGjhzp7nvppZc8ZtueHlt+fr7xxx9/FLivzzQTffjw4e72Jk2aGPn5+R772u12Y9GiRcacOXMKvR+KUpLHPyoqymPsa6+95u5LTk429u3bV+h+mzdvLjAD+qQ//vjDo++3334rsP/WrVuNd955x7Db7e6202ei67SZvaf3x8fHexyzsNnKp/5SYt26dUZgYKBH/7JlywzDMAyn01lg1vrLL7/s3jclJaXA7OsnnnjC4/zr168v8BgaxonH8dQZxr6+vh4z8E+fiS6dmIV//Phx95jc3FzDMAxj5MiRHuO6du1qpKenG4Zx4jl4yy23FDjW6c5nJvqhQ4cKzNQ/9fm5fv36Avfx6bOzd+zYUeisasMwjPfee89j3ylTpnj0n23m90nPPPOMx7hXXnnFo/+LL74o8m/dMIp/H5V0JnqbNm3cj+s///xT6ON+8rE+/ZcivXr1ch/X6XQa9erVc/eFh4cbW7Zscffn5eUV+DXPmjVrCr0GAACA0kJNdAAAUGaSk5M9FvOsUaOG+vXrJ0mKjo5Wr1693H1JSUlauHBhqcdwcuHSk3x8fHTDDTdIkvz8/DRo0KAixxbliSeecM/49vX11ZVXXunRf3LW5EkNGzbUF198of79+ysuLk7VqlVz1xU+ffZ9cetjS1K3bt3UpUsX9/ZHH33knt186ix0Sbr33nvd/z51tnpGRoZGjx6tL774Qn/99ZeOHz8uHx8fde3a1WMBz7M59ZgJCQl66qmnNHv2bK1bt06ZmZny8/PTpZde6nF/lzaXy+WxbbFY3P+uVauW9u3bp7vuukutW7dWaGiofHx8ZLFYPOqpS56PwanXJUkvvviiPvroIy1btkwHDx6UdGJ2+QMPPCA/P78iY6tTp46eeeYZ9/Yll1yi4OBg9/bpz5nT9e7d2+NXEhdccIGGDBniMebkbPe1a9e6Yzt57scee8y9HR4erueee85j3/nz53ts161bVy+//LJ69OihqKgo+fv7y2KxyN/fXytWrHCPy8/P9/glxul8fHw0bdo0hYWFudv8/f094j3p2Wefdd8nPj4+euWVV4o87kmffPKJDMNw30qyMObSpUs91kHo3Lmzx/OzXbt2Be7j0zVo0EA//fSTBg0apIYNGyooKEhWq1UWi6XAYskl+ds+1bx58zy2V65cqeuvv959++qrrzz6T38svWXMmDHux7VFixYej7EkjR071v1Y9+7d26Pv1Of7unXrtHfvXvd2tWrVNHbsWPf1DR482OP5LJXdNQIAgKqLci4AAKDMfP755x5JqkGDBslms7m3b775Zi1atMi9XdxyKiUxf/58jwX3Lr30UkVFRXnE8NFHH3nEcHry63SnLtApnSiVcqqTZTakE2VaevXq5VG65kzS0tKKNe6kRx99VNddd50k6ejRo/ryyy81dOhQzZw50z2me/fuatmypXt70KBBeuONN7RhwwZJ0tSpUzV16lR3f3x8vK688kqNGTOmwCKQRRk+fLimTZumvXv3Ki8vT6+99pq7z2KxqFmzZrr66qv1yCOPnHP5iDPJzMxUSkqKR9upj/Nbb72l0aNHF+tYpz4GderU0b333uu+f37++Wf9/PPP7v6IiAhdeumlGjlypHr06FHkMS+44AL5+nq+FQ8NDXWXzXE4HGeMqU2bNgXaTk/+nyzZkZiY6NHevHlz+fj4eLS1bdvWY/tkWSHpRLK3Z8+exSpTI535OVu/fv0in0OnlhiRpNatW3ts16lTR2FhYUpNTS1WHCV1tvNLBe/jUxmGoUGDBp2xnM2pSvq3fdKpj40kdwmnouzbt09Op7PAY17aTr+/goODPR6rU++7U78wkjxfI0+/vgMHDujrr78+47lP3wcAAKC0kUQHAABlZsaMGR7bs2fP1o8//ujePlmH+qT58+crJSVFNWrUKLUYPvnkE4/tP//8U3Xr1nVvG4bh0b927Vpt3rz5jMmz02tHnylZNXnyZI8EusViUYcOHVS3bl35+PgUqIt8ejxnc/XVV6tx48basWOH+3xNmzbVrl273GNOnYUuSQEBAVqxYoX++9//6ptvvtHatWs9EnwJCQmaPHmyvvjiC61fv77AbOzC1KpVSxs2bNCUKVP0ww8/aOPGjcrKynJf09atW7V161bNmjVLGzduVEhISImu82x++uknj9ra0omZ+pJ06NAhPf744x59sbGxat26tQIDAyXJI2l3+mMwZcoUXXbZZZo5c6ZWrlypQ4cOufuOHj2qr776SrNnz9bcuXPdtdRPd/pzRjrz8+Z8nB7/qTPyi2PMmDEeCfTAwEB16tRJNWrUkMViKVBj+0zP2ZiYmBKduyL5+uuvCyTQW7durfj4eNlsNh05ckS//fabu6+kf9vnyuVyKScnR9WrV/fqeU6feW61ev7oOTw83GvnPvnaAgAA4C2UcwEAAGVi7dq1+vvvvz3aUlNTdeDAAfft9JmuxS2nUlzJyckFSsRkZGR4xHB6mQCpYOL9fPz+++8e27NmzdLq1as1b948zZkzxz2L/FxZrVaPGdarV6/22I6IiND1119fYL/AwECNGjVKixYtUmpqqo4dO6ZVq1bp7rvvdo85fvy4pk+fXuxYwsPD9dRTT+mPP/5QRkaGkpOT9fvvv+vaa691j0lMTNTcuXNLeplnlJWVpWeffdajrVOnTu5FRf/880+PX0T0799fe/bs0Q8//KA5c+Zo0qRJZz3Hddddp6+//loHDx5UZmamNm/erHfeecedCDcMQ2+//XbpXdRpTv9bkqR//vnHY/vklx3x8fEe7Vu2bCnwBcOpC+2evs+pz1l/f39t27ZNS5Ys0ddff605c+aoadOmxY779MTqqerVq+exvXnzZo/tgwcPem0WenHOLxW8j091+t/2q6++qk2bNunbb7/VnDlzCnx5dbrifrlx6mNjsVh08OBBjxI2hd1OTaCX9EuUsnb68/Xyyy8/6/XNmTPHpGgBAEBVQRIdAACUiXNNRJdmAvv0cjLFNXPmzHParzCnz7avVq2a+9///vuv3nnnnfM+x9ChQz1KpJxas/r222931yU+acOGDfrggw88vkCoUaOGOnbsWCDhnpSUVKwYlixZos8++8xdUsVisahWrVrq3r27rrjiinM6ZnGsX79evXr10pYtW9xtPj4+HuVkTn8MAgIC3IlFu91+xjIv2dnZeumllzwSrEFBQWrZsqVuvfVWBQQEuNtL87pOt2jRIo/1BTZu3OhRskeS+vTpI0lq3769ateu7W4/cOCA3nzzTfd2amqqxo8f77HvqWWUTr2/rFare7a+dKI+96+//np+F3NavCe98MILyszMlCQ5nU49+eSTZz3GsGHD3OsLWCwWLV26tNjnv+SSSzxK7KxcudJjZvmmTZsK3MenOtPfdlJSkl588cUznv/U+1Uqui7+wIED3f82DEMjRoxQenp6gXGbNm3S2LFjPUozleQ8Zmnfvr3q1Knj3v7555/16aefFhiXm5urH3/8UTfeeKP2799fliECAIAqiHIuAADA6wqbUf73338XWiIlPz9f0dHR7rrlxSmnUlynJ+Tnz59fZM31tm3bumfnnlzktDTqs3fu3Nkj+Tlo0CD16NFD+fn5WrlyZYFE3LkICAjQyJEjNW7cOI92i8Wie+65p8D4xMRE3XvvvbrvvvvUsGFDxcfHKygoSCkpKQVqtzdv3rxYMWzcuFEPP/ywfHx81KRJE9WrV0+BgYFKSkrS6tWrz+mYhZk8ebK+//57ZWdna8eOHQUWtbRarZo0aZIuvvhid1vHjh1ltVrdC49+/fXXat26terVq6f169efMfntcDj0zDPP6JlnnlF0dLSaNm2qsLAw5ebmavXq1R5lJc7nus7GMAxdddVVuuiiixQQEKA///zTo650165d1bNnT0knvkR4+eWXdfvtt7v7H3/8cc2YMUN169bVunXrdPToUXdfrVq1PL5I6Ny5s5YsWSLpRE3/5s2bq1OnTkpKStK6detKbWbzQw89pI8++sh9HcuXL1ejRo3Url077dixQ7t37y6V8xSldu3auu222/Txxx+72wYNGqQLL7xQgYGBWrVqlXuh3sJ07txZU6ZMcW8/+OCD+uqrr+Tv768///zzrCVHmjVr5rE9ffp07dy50136Z+LEiYqNjdXo0aM1ffp09/N03rx5+uWXX9S+fXt3zfgtW7a4H9PTXwdOP899992nL774QoGBgQoJCfG4fjNYrVa99tpr7kVcXS6Xhg4dqnHjxqlZs2ayWq06ePCgtm7d6n6unPolGQAAgFcYAAAAXjZ79mxDkvvWsmXLM44fPny4x/jRo0e7+3r27OnRN3369GLFsHr1ao/9wsPDDYfDUeT4l156yWP8oEGDiowhISHBY9/p06d79I8bN87dl5KSYjRs2NCj/+StZs2axhNPPFHkvoZhGHFxcR79RTl69KhRrVo1j7GXXXZZoWPnzZtXaDyn39q3b29kZma69xs3blyRj8XEiROLdcwrr7zScDqdRV7H6U6/7890i42NNX7++edCj/PII48Uud8bb7zhsR0XF+fe7/jx48U6d82aNY3Nmze791uyZIlH/9ChQwvEdKbH9vTn1DXXXGPUrFmz0HPXrVvX2L17d4Hjv/LKK4aPj88Z465Xr56xdu1aj/1WrVplBAQEFDq+Y8eOxg033ODRtmTJEve+CQkJHn09e/Y84+P7ySefGFartdBzXX755Ubt2rXP+PwfOnRokbEUR2pqqtG+fftCzx8QEGDcfPPNRf59OhwOo1OnToXuGxgYaLzwwgtnfQ507NixyMfm77//do/7+++/jcaNGxfrufjCCy94nOPgwYNGSEhIkc/bk870OmYYZ38dPNtrVVF/Yye9++67hp+fX7Guce/evUU/qAAAAKWAci4AAMDrTp8BPnjw4DOOv+mmmzy2S6OcyukxXHfddbLZbMWO4eQip+crPDxcK1eu1D333KOYmBjZbDbFxMRo2LBh2rBhQ4nqS59JzZo1NWzYMI+2omoyd+/eXVOnTtXQoUPVpk0b1a5dW35+frLZbKpdu7b69OmjSZMm6Y8//lBQUFCxzn/dddfpnXfe0eDBg9WyZUtFRUXJZrPJ399fsbGx6t+/v2bMmKHvvvvujHWyi8PHx0fVqlVTnTp1dNFFF2nYsGGaM2eOdu/ercsuu6zQfd544w198MEHatu2rfz9/RUaGqqePXvqu+++O2M5l+DgYP3vf//TqFGj1LlzZ9WrV09BQUHy9fV1l8B5+umntXnzZrVs2fK8rutM2rZtq40bN+quu+5SnTp1ZLPZVKdOHd1///1as2ZNgbrS0onZ55s2bdLIkSPVqlUrBQcHy9fXVxEREerZs6feeustbd68We3bt/fYr2PHjlq5cqUGDhyosLAw+fv7q3Hjxho7dqyWLVvmUbbkfA0dOlTLli3T5ZdfrtDQUAUGBqpt27aaOHGi5s+fLz8/v1I7V2FCQ0P122+/aezYsWrUqJH8/PxUq1Yt3XjjjVq7dq369u1b5L42m02LFi3SY489pvr168tmsykyMlLXX3+9Vq9ere7du5/1/PPnz9fw4cMVGxvrUVrmdK1atdLGjRv14Ycf6sorr1RMTIz8/f1ls9kUFRWlbt26afTo0Vq0aJGeeuopj31r166tJUuWaMCAAYqIiDjvvz9vGTVqlLZu3arHH39cF110kcLDw91/6w0bNtTAgQP1xhtvaPfu3YqNjTU7XAAAUMlZDKOMloUHAABAmbrhhhvcC+7VqVNHiYmJZ0zMAQAAAAAK4lMUAABAJfLhhx/q2LFjWr9+vTuBLkljxowhgQ4AAAAA54CZ6AAAAJVI/fr1tWfPHo+2bt26acmSJWcsXwMAAAAAKFz5LIAHAACA8+Ln56dGjRrp6aef1sKFC0mgAwAAAMA5YiY6AAAAAAAAAABFYCY6AAAAAAAAAABFIIkOAAAAAAAAAEARSKIDAAAAAAAAAFAEkugAAAAAAAAAABSBJDoAAAAAAAAAAEUgiQ4AAAAAAAAAQBFIogMAAAAAAAAAUASS6AAAAAAAAAAAFIEkOgAAAAAAAAAARSCJDgAoksVi0fjx471+nqVLl8pisWjp0qXutksuuUStWrXy+rklKTExURaLRZ988kmZnA8AAAA4F/n5+XrssccUGxsrq9Wqa665xuyQypXCPleUprL6fASg/CGJDsBrdu3apXvuuUcNGjRQQECAQkJC1K1bN73zzjvKyckxO7wK74svvtDbb79d7PH169eXxWKRxWKR1WpVWFiYWrdurbvvvlurVq0yLa6yVJ5jAwAAwPl5//33ZbFY1KlTpyLHnHw/fPI9cUxMjPr27Vsg6Vq/fn1dddVVZz2ny+XSp59+qk6dOqlGjRoKDg5WkyZNdNttt+nPP/8830sq4OOPP9brr7+u66+/XjNmzNDDDz9c6ucoLT/++KMsFotiYmLkcrnMDgcAzouv2QEAqJx++OEH3XDDDfL399dtt92mVq1ayeFwaPny5Xr00Uf1zz//aNq0aWaHWaF98cUX2rx5sx566KFi79OuXTuNHj1akpSRkaGtW7dq9uzZ+vDDD/Xwww/rrbfe8hifk5MjX9+S/VdxLnFdfPHFysnJkZ+fX4nOVVJFxRYXF6ecnBzZbDavnh8AAADeM3PmTNWvX19//fWXdu7cqUaNGhU67rLLLtNtt90mwzCUkJCg999/X5deeql++OEHXXHFFSU65wMPPKDJkyfr6quv1pAhQ+Tr66vt27drwYIFatCggTp37lwal+a2ePFi1alTRxMnTizV43rDyccjMTFRixcvVp8+fcwO6bydy+cjAJUDf/kASl1CQoIGDx6suLg4LV68WLVr13b3jRgxQjt37tQPP/xgYoRVV506dXTLLbd4tL366qv6z3/+o4kTJ6px48a677773H0BAQFejSc3N1d+fn6yWq1eP9eZWCwWU88PAACA85OQkKAVK1Zo7ty5uueeezRz5kyNGzeu0LFNmjTxeE987bXXqk2bNnr77bdLlERPTk7W+++/r+HDhxeYIPT222/ryJEj53YxpzEMQ7m5uQoMDNThw4cVFhZWKsf1pqysLH377beaMGGCpk+frpkzZ1aKJDqfGYCqi3IuAErda6+9pszMTH300UceCfSTGjVqpAcffNC9nZ+frxdeeEENGzaUv7+/6tevr6eeekp2u91jv5M/qVy6dKkuvPBCBQYGqnXr1u6fXs6dO1etW7dWQECAOnTooPXr13vsP2zYMFWvXl27d+9Wv379FBQUpJiYGD3//PMyDMNjbFZWlkaPHq3Y2Fj5+/uradOmeuONNwqMs1gsGjlypL755hu1atVK/v7+atmypRYuXFjgug8cOKA77rhDUVFR7nEff/yxx5iTNfy++uorvfTSS6pbt64CAgLUu3dv7dy50z3ukksu0Q8//KA9e/a4f45av379oh+UMwgMDNRnn32mGjVq6KWXXvK4xtNr/mVkZOihhx5S/fr15e/vr1q1aumyyy7TunXrzhrXyWubNWuWnnnmGdWpU0fVqlVTenr6GWsXrl27Vl27dlVgYKDi4+M1depUj/5PPvlEFotFiYmJhd6XJ495ptiKqom+ePFi9ejRQ0FBQQoLC9PVV1+trVu3eowZP368LBaLdu7cqWHDhiksLEyhoaG6/fbblZ2dXbwHAQAAAOdl5syZCg8PV//+/XX99ddr5syZxd63devWioiIUEJCQonOmZCQIMMw1K1btwJ9FotFtWrVcm+ffM94usLey5783PPTTz+5P/d88MEHslgsWrJkif755x/3+9mT73XfeOMNde3aVTVr1lRgYKA6dOigOXPmFBr3559/ro4dO6patWoKDw/XxRdfrJ9//tljzIIFC9zvg4ODg9W/f3/9888/xb5v5s2bp5ycHN1www0aPHiw5s6dq9zc3ELvp+J8ntqzZ4/uv/9+NW3aVIGBgapZs6ZuuOGGAp8BTjdu3DjZbLZCv9C4++67FRYW5o5rzZo16tevnyIiItyfPe64444C8Zbk8xGAyoOZ6ABK3fz589WgQQN17dq1WOPvuusuzZgxQ9dff71Gjx6tVatWacKECdq6davmzZvnMXbnzp36z3/+o3vuuUe33HKL3njjDQ0YMEBTp07VU089pfvvv1+SNGHCBN14443avn27rNb//32h0+nU5Zdfrs6dO+u1117TwoULNW7cOOXn5+v555+XdGKmx8CBA7VkyRLdeeedateunX766Sc9+uijOnDgQIGfTi5fvlxz587V/fffr+DgYL377rsaNGiQ9u7dq5o1a0o6MUulc+fO7jeJkZGRWrBgge68806lp6cXKC/yyiuvyGq1asyYMUpLS9Nrr72mIUOGuGuXP/3000pLS9P+/fvd8VSvXr2Yj1BB1atX17XXXquPPvpIW7ZsUcuWLQsdd++992rOnDkaOXKkWrRooWPHjmn58uXaunWr2rdvX6y4XnjhBfn5+WnMmDGy2+1nLOFy/PhxXXnllbrxxht1880366uvvtJ9990nPz+/Am9oz6ak99mvv/6qK664Qg0aNND48eOVk5OjSZMmqVu3blq3bl2BLy1uvPFGxcfHa8KECVq3bp3++9//qlatWnr11VdLFCcAAABKbubMmbruuuvk5+enm2++WVOmTNHq1at10UUXnXXf48eP6/jx40WWfylKXFycJGn27Nm64YYbVK1atXOKvTDbt2/XzTffrHvuuUfDhw9X3bp19dlnn+mll15SZmamJkyYIElq3ry5JOmdd97RwIEDNWTIEDkcDs2aNUs33HCDvv/+e/Xv39993Oeee07jx49X165d9fzzz8vPz0+rVq3S4sWL1bdvX0nSZ599pqFDh6pfv3569dVXlZ2drSlTpqh79+5av359sSbvzJw5U7169VJ0dLQGDx6sJ554QvPnz9cNN9xQYGxxPk+tXr1aK1as0ODBg1W3bl0lJiZqypQpuuSSS7Rly5Yi7/tbb71Vzz//vL788kuNHDnS3e5wODRnzhwNGjRIAQEBOnz4sPr27avIyEg98cQTCgsLU2JioubOnXvG6zzb5yMAlYgBAKUoLS3NkGRcffXVxRq/YcMGQ5Jx1113ebSPGTPGkGQsXrzY3RYXF2dIMlasWOFu++mnnwxJRmBgoLFnzx53+wcffGBIMpYsWeJuGzp0qCHJGDVqlLvN5XIZ/fv3N/z8/IwjR44YhmEY33zzjSHJePHFFz1iuv766w2LxWLs3LnT3SbJ8PPz82jbuHGjIcmYNGmSu+3OO+80ateubRw9etTjmIMHDzZCQ0ON7OxswzAMY8mSJYYko3nz5obdbnePe+eddwxJxt9//+1u69+/vxEXF1fIvVq4uLg4o3///kX2T5w40ZBkfPvttx7XN27cOPd2aGioMWLEiDOep6i4Tl5bgwYN3Nd7et+pj1fPnj0NScabb77pbrPb7Ua7du2MWrVqGQ6HwzAMw5g+fbohyUhISDjrMYuKLSEhwZBkTJ8+3d128jzHjh1zt23cuNGwWq3Gbbfd5m4bN26cIcm44447PI557bXXGjVr1ixwLgAAAJSuNWvWGJKMX375xTCME+/x69atazz44IMFxkoy7rzzTuPIkSPG4cOHjVWrVhm9e/cu8L7zbO+dT7rtttsMSUZ4eLhx7bXXGm+88YaxdevWAuNOvmc8XWHvZU9+7lm4cGGB8T179jRatmxZoP3099cOh8No1aqVcemll7rbduzYYVitVuPaa681nE6nx3iXy2UYhmFkZGQYYWFhxvDhwz36k5KSjNDQ0ALthUlOTjZ8fX2NDz/80N3WtWvXQj8jFvfz1OnXZxiGsXLlSkOS8emnn7rbCvsM0KVLF6NTp04e+86dO9dj3Lx58wxJxurVq894befy+QhA5UA5FwClKj09XZIUHBxcrPE//vijJOmRRx7xaD+5+OXptdNbtGihLl26uLc7deokSbr00ktVr169Au27d+8ucM5TZyCcnBnucDj066+/umPy8fHRAw88UCAmwzC0YMECj/Y+ffqoYcOG7u02bdooJCTEfW7DMPT1119rwIABMgxDR48edd/69euntLS0Aj/3u/322z1maPfo0aPI6yktJ2dlZ2RkFDkmLCxMq1at0sGDB8/5PEOHDlVgYGCxxvr6+uqee+5xb/v5+emee+7R4cOHtXbt2nOO4WwOHTqkDRs2aNiwYapRo4a7vU2bNrrsssvcz9tT3XvvvR7bPXr00LFjx9x/EwAAAPCOmTNnKioqSr169ZJ04j3+TTfdpFmzZsnpdBYY/9FHHykyMlK1atVSp06d9Mcff+iRRx4p8OvQ4pg+fbree+89xcfHa968eRozZoyaN2+u3r1768CBA+d8TfHx8erXr1+xx5/6/vr48eNKS0tTjx49PD5nfPPNN3K5XHr22Wc9fq0ryV1q5pdfflFqaqpuvvlmj88tPj4+6tSpk5YsWXLWWGbNmiWr1apBgwa5226++WYtWLBAx48fLzD+bJ+nTr++vLw8HTt2TI0aNVJYWNhZS6fcdtttWrVqlXbt2uVumzlzpmJjY9WzZ09JcteZ//7775WXl3fWazypND4fAagYSKIDKFUhISGSzpyIPdWePXtktVoL/HQyOjpaYWFh2rNnj0f7qYlySQoNDZUkxcbGFtp++ps0q9WqBg0aeLQ1adJEktz19Pbs2aOYmJgCXwSc/Knk2WKSpPDwcPe5jxw5otTUVE2bNk2RkZEet9tvv12SdPjw4TMeMzw8vNDrKU2ZmZmSzvwFyGuvvabNmzcrNjZWHTt21Pjx40uc2I+Pjy/22JiYGAUFBXm0nf54ecPJx7hp06YF+po3b66jR48qKyvLo92MxwwAAKCqczqdmjVrlnr16qWEhATt3LlTO3fuVKdOnZScnKxFixYV2Ofqq6/WL7/8ol9//VWrVq3S0aNH9eabbxZILBeH1WrViBEjtHbtWh09elTffvutrrjiCi1evFiDBw8+5+sqyXtm6UTyt3PnzgoICFCNGjUUGRmpKVOmKC0tzT1m165dslqtatGiRZHH2bFjh6QTk5RO/+zy888/F/jcUpiTNdePHTvmfjwuuOACORwOzZ49u8D4s32ekqScnBw9++yz7jWrIiIiFBkZqdTUVI9rLMxNN90kf39/d538tLQ0ff/99xoyZIj7y4OePXtq0KBBeu655xQREaGrr75a06dPL7BO1+lK4/MRgIqBmugASlVISIhiYmK0efPmEu1X2CI7hfHx8SlRu3HaQqDecLZzu1wuSdItt9yioUOHFjq2TZs2JTqmN5x8zM5UC/LGG29Ujx49NG/ePP388896/fXX9eqrr2ru3Lm64oorinWe4s5CL66injuFzTryJjOfgwAAAFXV4sWLdejQIc2aNUuzZs0q0D9z5kx3re+T6tatqz59+pR6LDVr1tTAgQM1cOBAXXLJJVq2bJn27NmjuLi4Er9nLcl75t9//10DBw7UxRdfrPfff1+1a9eWzWbT9OnT9cUXX5ToGk5+dvnss88UHR1doN/X98xppB07dmj16tWSpMaNGxfonzlzpu6++26PtuK8jx41apSmT5+uhx56SF26dFFoaKgsFosGDx7sjrko4eHhuuqqqzRz5kw9++yzmjNnjux2u2655Rb3GIvFojlz5ujPP//U/Pnz9dNPP+mOO+7Qm2++qT///LPItZRK4/MRgIqBJDqAUnfVVVdp2rRpWrlypUfplcLExcXJ5XJpx44d7pne0omFOFNTU92L9ZQWl8ul3bt3u2czS9K///4rSe4FcuLi4vTrr78qIyPDY1b2tm3b3P0lERkZqeDgYDmdzlJ9s17cLx6KIzMzU/PmzVNsbKzH41CY2rVr6/7779f999+vw4cPq3379nrppZfcbxJLM66DBw8qKyvLYzb66Y/XyRnfqampHvue/ouBksR28jHevn17gb5t27YpIiKiwAx5AAAAlL2ZM2eqVq1amjx5coG+uXPnat68eZo6dWqpT+Q4mwsvvFDLli3ToUOHFBcX5/Ge9WTpEKnw96wl9fXXXysgIEA//fST/P393e3Tp0/3GNewYUO5XC5t2bJF7dq1K/RYJ8uq1KpV65w+u8ycOVM2m02fffZZgeT48uXL9e6772rv3r2Fzj4/kzlz5mjo0KF688033W25ubkFPgMU5bbbbtPVV1+t1atXa+bMmbrgggvUsmXLAuM6d+6szp0766WXXtIXX3yhIUOGaNasWbrrrruKPPbZPh8BqBwo5wKg1D322GMKCgrSXXfdpeTk5AL9u3bt0jvvvCNJuvLKKyVJb7/9tseYt956S5I8VpIvLe+9957734Zh6L333pPNZlPv3r3dMTmdTo9xkjRx4kRZLJYSvxny8fHRoEGD9PXXXxc6Q//IkSPncBVSUFDQWX+6WBw5OTm69dZblZKSoqeffvqMs2ROP1+tWrUUExPj8TPH0opLkvLz8/XBBx+4tx0Ohz744ANFRkaqQ4cOkv7/G/3ffvvNI9Zp06YVOF5xY6tdu7batWunGTNmeLwx37x5s37++Wf38xYAAADmycnJ0dy5c3XVVVfp+uuvL3AbOXKkMjIy9N1333nl/ElJSdqyZUuBdofDoUWLFnmUrSzsPWtWVpZmzJhx3nH4+PjIYrF4zGpPTEzUN9984zHummuukdVq1fPPP19g9vbJWd/9+vVTSEiIXn755UJrg5/ts8vMmTPVo0cP3XTTTQUej0cffVSS9L///e+crvH0X3hOmjSp2L8+veKKKxQREaFXX31Vy5Yt85iFLp0owXj68U9+0VBUSZfifj4CUDkwEx1AqWvYsKG++OIL3XTTTWrevLluu+02tWrVSg6HQytWrNDs2bM1bNgwSVLbtm01dOhQTZs2TampqerZs6f++usvzZgxQ9dcc417caDSEhAQoIULF2ro0KHq1KmTFixYoB9++EFPPfWUIiMjJUkDBgxQr1699PTTTysxMVFt27bVzz//rG+//VYPPfSQx6I3xfXKK69oyZIl6tSpk4YPH64WLVooJSVF69at06+//qqUlJQSH7NDhw768ssv9cgjj+iiiy5S9erVNWDAgDPuc+DAAX3++eeSTsw+37Jli2bPnq2kpCSNHj3aYxHP02VkZKhu3bq6/vrr1bZtW1WvXl2//vqrVq9e7TEj5FziKkpMTIxeffVVJSYmqkmTJvryyy+1YcMGTZs2TTabTZLUsmVLde7cWU8++aRSUlJUo0YNzZo1S/n5+QWOV5LYXn/9dV1xxRXq0qWL7rzzTuXk5GjSpEkKDQ3V+PHjz+l6AAAAUHq+++47ZWRkaODAgYX2d+7cWZGRkZo5c6ZuuummUj///v371bFjR1166aXq3bu3oqOjdfjwYf3vf//Txo0b9dBDDykiIkKS1LdvX9WrV0933nmnHn30Ufn4+Ojjjz9WZGSk9u7de15x9O/fX2+99ZYuv/xy/ec//9Hhw4c1efJkNWrUSJs2bXKPa9SokZ5++mm98MIL6tGjh6677jr5+/tr9erViomJ0YQJExQSEqIpU6bo1ltvVfv27TV48GB3jD/88IO6detWYLLRSatWrdLOnTs1cuTIQvvr1Kmj9u3ba+bMmXr88cdLdI1XXXWVPvvsM4WGhqpFixZauXKlfv31V9WsWbNY+9tsNg0ePFjvvfeefHx8dPPNN3v0z5gxQ++//76uvfZaNWzYUBkZGfrwww8VEhJS5ASa4n4+AlBJGADgJf/++68xfPhwo379+oafn58RHBxsdOvWzZg0aZKRm5vrHpeXl2c899xzRnx8vGGz2YzY2FjjySef9BhjGIYRFxdn9O/fv8B5JBkjRozwaEtISDAkGa+//rq7bejQoUZQUJCxa9cuo2/fvka1atWMqKgoY9y4cYbT6fTYPyMjw3j44YeNmJgYw2azGY0bNzZef/11w+VynfXcJ2MdOnSoR1tycrIxYsQIIzY21rDZbEZ0dLTRu3dvY9q0ae4xS5YsMSQZs2fPLvR6pk+f7m7LzMw0/vOf/xhhYWGGJCMuLq5AHKfHJMmQZFgsFiMkJMRo2bKlMXz4cGPVqlWF7iPJGDdunGEYhmG3241HH33UaNu2rREcHGwEBQUZbdu2Nd5//32PfYqKq6hrO7VvyZIl7raePXsaLVu2NNasWWN06dLFCAgIMOLi4oz33nuvwP67du0y+vTpY/j7+xtRUVHGU089Zfzyyy8FjllUbIXdv4ZhGL/++qvRrVs3IzAw0AgJCTEGDBhgbNmyxWPMuHHjDEnGkSNHPNqnT59uSDISEhIKvW8BAABwfgYMGGAEBAQYWVlZRY4ZNmyYYbPZjKNHjxqGUfT799MV9dnjVOnp6cY777xj9OvXz6hbt65hs9mM4OBgo0uXLsaHH35Y4LPD2rVrjU6dOhl+fn5GvXr1jLfeeqvQ94xnOvfJ98in++ijj4zGjRsb/v7+RrNmzYzp06e736ee7uOPPzYuuOACw9/f3wgPDzd69uxp/PLLLx5jlixZYvTr188IDQ01AgICjIYNGxrDhg0z1qxZU+T9MWrUKEOSsWvXriLHjB8/3pBkbNy40TCM4n+eOn78uHH77bcbERERRvXq1Y1+/foZ27ZtKzCusM8VJ/3111+GJKNv374F+tatW2fcfPPNRr169Qx/f3+jVq1axlVXXVXges/l8xGAysFiGKx4BqBqGDZsmObMmaPMzEyzQwEAAAAAlKGNGzeqXbt2+vTTT3XrrbeaHQ6ACoaa6AAAAAAAAKjUPvzwQ1WvXl3XXXed2aEAqICoiQ4AAAAAAIBKaf78+dqyZYumTZumkSNHKigoyOyQAFRAJNEBAAAAAABQKY0aNUrJycm68sor9dxzz5kdDoAKiproAAAAAAAAAAAUgZroAAAAAAAAAAAUgSQ6AAAAAAAAAABFoCY6AAAAAJzC5XLp4MGDCg4OlsViMTscAAAAeIlhGMrIyFBMTIys1qLnm5NEBwAAAIBTHDx4ULGxsWaHAQAAgDKyb98+1a1bt8h+kugAAAAAcIrg4GBJJz5MhYSEmBwNAAAAvCU9PV2xsbHu939FIYkOAAAAAKc4WcIlJCSEJDoAAEAVcLYSfiwsCgAAAAAAAABAEUiiAwAAAAAAAABQBJLoAAAAAAAAAAAUgSQ6AAAAAAAAAABFIIkOAAAAAAAAAEARSKIDAAAAAAAAAFAEkugAAAAAAAAAABSBJDoAAAAAAAAAAEUgiQ4AAAAAAAAAQBFIogMAAAAAAAAAUASS6AAAAAAAAAAAFIEkOgAAAAAAAAAARSCJDgAAAAAAAABAEUiiAwAAAAAAAABQBJLoAAAAAAAAAAAUgSQ6AJSSpUuXymKxKDU1tdj7DBs2TNdcc43XYgIAAAAAAMD5IYkOoMoYNmyYLBaL7r333gJ9I0aMkMVi0bBhw8o+MAAAAAAAAJRbvmYHAADnw2KxaN68ecWezR0bG6tZs2Zp4sSJCgwMlCTl5ubqiy++UL169bwYKQAAAADgTJIG9DA7BAAmi57/u9khFIqZ6ADKtaSkJI0aNUoNGjSQv7+/YmNjNWDAAC1atOicjte+fXvFxsZq7ty57ra5c+eqXr16uuCCC9xtdrtdDzzwgGrVqqWAgAB1795dq1ev9jjWjz/+qCZNmigwMFC9evVSYmKiR//48ePVrl07j7a3335b9evXLzI+l8ulCRMmKD4+XoGBgWrbtq3mzJnj7j9+/LiGDBmiyMhIBQYGqnHjxpo+fXrJ7wgAAAAAAAAUC0l0AOVWYmKiOnTooMWLF+v111/X33//rYULF6pXr14aMWLEOR/3jjvu8Eg8f/zxx7r99ts9xjz22GP6+uuvNWPGDK1bt06NGjVSv379lJKSIknat2+frrvuOg0YMEAbNmzQXXfdpSeeeOKcYzppwoQJ+vTTTzV16lT9888/evjhh3XLLbdo2bJlkqSxY8dqy5YtWrBggbZu3aopU6YoIiLivM8LAAAAAACAwlHOBUC5df/998tiseivv/5SUFCQu71ly5a64447Ct3n8ccf17x587R//35FR0dryJAhevbZZ2Wz2SRJaWlp+vrrr/XHH38oODhY9evX17///qtZs2bpxx9/1Nq1axUeHq7U1FTVqVNHhmGoRYsW+vDDD/Xjjz+qa9eu2r9/vwzDUEBAgJ588klFRESoadOmmj17tr799lvVrl1b1apVU2hoqEfcZ2O32/Xyyy/r119/VZcuXSRJDRo00PLly/XBBx+oZ8+e2rt3ry644AJdeOGFknTGWe0AAAAAAAA4f8xEB1AupaSkaOHChRoxYkShieiwsLBC9wsODtYnn3yiLVu26J133tGHH36oiRMnuvvXrl2r+Ph4XXbZZbr99tvVrFkz9ejRQxEREdq0aZOcTqf++9//SpKef/55Va9eXZKUlZWltLQ0+fv7a82aNerYsaOCgoJ04403SpIOHTqk77//XpK0atUqLV26VM2bNy/RNe/cuVPZ2dm67LLLVL16dfft008/1a5duyRJ9913n2bNmqV27drpscce04oVK0p0DgAAAAAAAJQMM9EBlEs7d+6UYRhq1qxZifZ75pln3P+uX7++xowZo1mzZumxxx6TJOXk5KhPnz6KiIjQyJEjJUmTJ09298XHx6tx48aSpN69eysuLk6S9N577yksLEwdOnRQs2bNFBYWpu7du+urr77Sv//+q8zMTDmdTklSvXr1FBYWpk6dOmn//v0e8eXl5RUZe2ZmpiTphx9+UJ06dTz6/P39JUlXXHGF9uzZox9//FG//PKLevfurREjRuiNN94o0f0EAAAAAACA4iGJDqBcMgzjnPb78ssv9e6772rXrl3KzMxUfn6+QkJC3P0NGzbUXXfdpYsvvljHjh1TtWrV1K9fP0knSqds3LhR99xzj6xWq/73v/+565yvX79ehw8f1syZM/XVV1/J4XC4k+a7du1S3759FRcXpz179mjYsGHq37+/goKClJSUJMMwZLFYJEkbNmwoMvYWLVrI399fe/fuVc+ePYscFxkZqaFDh2ro0KHq0aOHHn30UZLoAAAAAAAAXkISHUC51LhxY1ksFm3btq3Y+6xcuVJDhgzRc889p379+ik0NFSzZs3Sm2++6R7TrFkzfffdd/rhhx9kGIb++OMPfffdd7r22msVFxenRo0aqXfv3jpy5IiefPJJ7dmzR6NGjdKqVatks9m0YsUKhYaG6uDBg+rTp49uv/12RUdH68svv1Rubq4kqWnTppo0aZIOHDiglJQUvfbaa7r++uu1cOFCLViwwCOpf6rg4GCNGTNGDz/8sFwul7p37660tDT98ccfCgkJ0dChQ/Xss8+qQ4cOatmypex2u77//vsSl40BAAAAAABA8VETHUC5VKNGDfXr10+TJ09WVlZWgf7U1NQCbStWrFBcXJyefvppXXjhhWrcuLH27NlTYFyTJk308MMPa/Hixbruuus0ffp0d19QUJDuvfdebd68WR06dNCHH36o9u3by2KxKCYmRm3btlWjRo108cUXa+7cuVq2bJm6dOmiqVOnasKECZKkJ598UuvXr1dgYKAGDRqkyZMnq23btvrrr780ZsyYM173Cy+8oLFjx2rChAlq3ry5Lr/8cv3www+Kj4+XJPn5+enJJ59UmzZtdPHFF8vHx0ezZs0qyV0LAAAAAACAEiCJDqDcmjx5spxOpzp27Kivv/5aO3bs0NatW/Xuu++qS5cuBcY3btxYe/fu1axZs7Rr1y69++67mjdvnrt/ypQpqlu3rpYuXao9e/bojz/+0OrVq90zuevXr6+bb75ZCQkJ2rJli3x9fTVo0CDl5uZq1apVys7O1s0336zVq1dr165dstls6t69u7KysvT666/r0KFDWr16tdLT0zV37lwdOXJEd955p/bu3avMzEzNmDFDTz31lBITE90xffLJJ/rmm2/c2xaLRQ8++KC2bdsmh8Ohw4cPa+HChbr44oslnaj5vmXLFmVnZ+vYsWP65ptv3Al2AAAAAAAAlD7KuQAotxo0aKB169bppZde0ujRo3Xo0CFFRkaqQ4cOmjJlSoHxAwcO1MMPP6yRI0fKbrerf//+Gjt2rMaPHy9J8vHx0bFjx3TbbbcpOTlZERERuu666/Tcc89JkpxOp0aMGKH9+/crJCREl19+uSZOnChJiomJ0R9//KHHH39cffv2ld1uV1xcnC6//HJZrVaFhITot99+09tvv6309HTFxcXpzTff1BVXXFFm9xcAAAAAAABKn8U419X7AAAAAKASSk9PV2hoqNLS0opcywQAUPqSBvQwOwQAJoue/3uZnq+47/so5wIAAAAAAAAAQBFIogMAAAAAAAAAUASS6AAAAAAAAAAAFIEkOgAAAAAAAAAARSCJDgAAAAAAAABAEUiiAwAAAAAAAABQBJLoAAAAAAAAAAAUgSQ6AAAAAAAAAABF8DU7AABAyTkNQzlOp3JcTkUeT5Xy8qT8fMnlct82R8TIYrHIarHIxyL5WCz/d5N8rVaF+vmomq+P2ZcCAAAAAABQrpFEB4Bywu5yKsXh0LE8h1L+73bqv4/nOZSZn68cl1P5huHe76v/fSP/nJwCx3t8wD3KO2VcYQJ8rAr381W4v69q+Psq3N+mcD9f1fy/f59o81W4n02+VkupXzMAAAAAAEB5RxIdAMpQtjNf+3JzdCA3R/tys3UgN0eH7Lk6lmdXltN5Tse0BwQUmkQvjlynS4dyHDqU4zjjOIukYJuPwv19VdPfprjqAWoYEqBGIYGKCwqQDwl2AAAAAABQSZFEBwAvcBqGDuTmKDEnS3tyspWYk6XEnCwdzTtzsvpc2AMDpOOlflgPhqT0PKfS85zak2nXumOZ7j6b1XIiqR58IqneMCRQDYIDKBUDAAAAAAAqBZLoAFAK7C6n/s3K1NbMdP2Tma7tWRnKcZ3bzPISn9vfv0zOU5Q8l6Gd6TnamZ6jnw6cyOZbJNWu5nciqR4cqIYhAWoYHKiaATZTYwUAAAAAACgpkugAcA4y8vO0JTNdWzLTtTUrQ7uyMz3qlJclR4C5SfTCGJIOZjt0MNuh35LS3O01/X3VISJYHSOD1aFmsIJszFYHAAAAAADlG0l0ACgGh8ulTRmpWpt+XH9npGl/bo7MSZkXZPfzMzuEYjtmz9fPB47r5wPH5WORWoQF6aLIE0n1BsGBZocHAAAAAABQAEl0ACjCMbtDf6Uf09q049qUmSa7y2V2SIVymFzO5Vw5Denv41n6+3iWPv43SREBNl0UEayLIoPVoWZ1BVJTHQAAAAAAlAMk0QHgFIey7fo9OU3Lk9KVlpen1OopZod0Vna/ylFn/GhunhbsT9GC/SmyWSxqGR6kjpEnkupx1QPMDg8AAAAAAFRRJNEBVHl7M3P/L3Gepl0ZuR59sSEBOurKLWLP8sFRgcq5FFeeYWhDSqY2pGRq2vZDigq0qUdUqPrWqaH6wSTUAQAAAABA2SGJDqBKyspz6ucDx7Vgf4oSM4tOktc0quuoyncS3W6r/C/lyTl5mpN4VHMSj6pxSKD61glXr9phCvGr/NcOAAAAAADMRfYBQJWyMz1H8/ce0+JDx2V3nn1p0LQcSeV84rPdVjnKuRTXjvQc7UjP0bRth9SpVoj61gnXRZHB8rFYzA4NAAAAAABUQiTRAVR6DqdLS5NS9f3eFG1Lyy7RvnvS7YoItCnDyPNSdOfP4Vs1X8rzDEPLk9O0PDlNEf42XRFbQ1fWraGaAVXrSwUAAAAAAOBdVrMDAABvOZht17RtB3Xz0q164+/9JU6gS5JLUrQluPSDK0X2KppEP9VRe54+25msW5Zt1fPr92j9sQwZxtl/aQAAKF9+++03DRgwQDExMbJYLPrmm288+g3D0LPPPqvatWsrMDBQffr00Y4dOzzGpKSkaMiQIQoJCVFYWJjuvPNOZWZmluFVAAAAoLIhiQ6gUnEahlYkp+nJ1bt1+2/bNSfxqDLynOd1zDy7TylF5x0O3/IdX1lyGtLy5DQ9vjpBd/6+XV8nHlHWeT7+AICyk5WVpbZt22ry5MmF9r/22mt69913NXXqVK1atUpBQUHq16+fcnP///olQ4YM0T///KNffvlF33//vX777TfdfffdZXUJAAAAqISYvgigUkix52nB/hT9uC9FR3JLt/TK7jS7/COsypOrVI9bWuw+JNELsz/boQ+2HdLMnYd1Xf0IXVs/QkF84QAA5doVV1yhK664otA+wzD09ttv65lnntHVV18tSfr0008VFRWlb775RoMHD9bWrVu1cOFCrV69WhdeeKEkadKkSbryyiv1xhtvKCYmpsyuBQAAAJUHM9EBVGhpjnx9sO2gblu2TTN2JJd6Al2S7C5DsT7lt6SLw8pL+Zlk5jv16c5k3bZsm77YlazsfGamA0BFlJCQoKSkJPXp08fdFhoaqk6dOmnlypWSpJUrVyosLMydQJekPn36yGq1atWqVWUeMwAAACoHZqIDqJCy852ak3BEcxOPKtvp/Rni1jy/cvu1o92nnAZWzmTkOfXJjmTNTTyq6+MjdXW9mgpkZjoAVBhJSUmSpKioKI/2qKgod19SUpJq1arl0e/r66saNWq4xxTGbrfLbre7t9PT00srbAAAAFQCZF4AVCgOp0tzEo5o6LJt+nzX4TJJoEvSvvQ8qZyuU2lnJnqJpOc59fG/Sbpt2TZ9tfuwcvLLZ5keAEDZmTBhgkJDQ9232NhYs0MCAABAOULmBUCF4HQZ+nHfMQ37fbumbT+ktDJeLDLV4VQdn+ples7iclgtZodQIaXlOfXff5M09LdtmpNwRPYy+kIGAHBuoqOjJUnJycke7cnJye6+6OhoHT582KM/Pz9fKSkp7jGFefLJJ5WWlua+7du3r5SjBwAAQEVGEh1AuWYYhpYeStXw5dv19j8HdNQLNc+Lq7or0LRzn4ndQhL9fKQ68jVt+yHdtmybvk48IgfJdAAol+Lj4xUdHa1Fixa529LT07Vq1Sp16dJFktSlSxelpqZq7dq17jGLFy+Wy+VSp06dijy2v7+/QkJCPG4AAADASdREB1Bu/XUkXZ/sSNLO9FyzQ5EkHc50SeVwMrr97ENQDMcd+fpg2yHNTjii/zSopf71asqHLygAoExlZmZq586d7u2EhARt2LBBNWrUUL169fTQQw/pxRdfVOPGjRUfH6+xY8cqJiZG11xzjSSpefPmuvzyyzV8+HBNnTpVeXl5GjlypAYPHqyYmBiTrgoAAAAVHUl0AOXOP8ez9NG/Sdp8PMvsUDwczHaobmiAjjnLR1L/JAd53lKVYs/Xe1sPauGB43q4ZR01Dq1mdkgAUGWsWbNGvXr1cm8/8sgjkqShQ4fqk08+0WOPPaasrCzdfffdSk1NVffu3bVw4UIFBAS495k5c6ZGjhyp3r17y2q1atCgQXr33XfL/FoAAABQeVgMwyinS+UBqGrSHfmauu2Qfj143OxQitQu2l/bXUfNDsNDtK9NH0z7tEB7/wH3KI+X+PNitUhX14vQsMZRCvT1MTscAEAZSU9PV2hoqNLS0ijtAgBlKGlAD7NDAGCy6Pm/l+n5ivu+j5noAMqF35PS9N6WAzruyDc7lDPKyJYUcNZhZcpBotxrXIY0b89R/ZGcphEt6qhLLRIpAAAAAABUNSTRAZgqxZ6n97Yc0PLkdLNDKZaEDLtqBPoqyyg/yX47SXSvO5ybp3HrEtU9KlQjmseoZoDN7JAAAAAAAEAZIYkOwDQ/H0jRB9sOKSPPaXYoxeYypBhriHY4U8wOxc1huMwOocpYnpymdccydEeTaF0VW1NWFh4FAAAAAKDSI4kOoMwdznHo7X8OaM3RDLNDOSf5dp9y9eqZZxhyWSyyMiO9TGTnu/TeloNadCBVD7Wqo/jgQLNDAgAAAAAAXmQ1OwAAVYdhGPpu71HdvfzfCptAl6TdaQ75qnzNQHYElLNC7VXA1rRsjVixUx9tPyS7k18DAAAAAABQWZFEB1AmDmTZNeav3Xpvy0FlV/CEY67TpVif8rXApL0as6HNkG8Y+jLhiO5e/q82HMs0OxwAAAAAAOAFJNEBeJXTMPRVwmHd+8e/+vt4ltnhlBrfPD+zQ/Dg8Pc3O4Qq7VCOQ0+s3q3PdybLoKwOAAAAAACVSjmq6gugsjmc49BLG/Zqa1q22aGUuv0Z+VKIVF6qutgp52I6l6RPdyZra2q2Hm8TqxA//osFAAAAAKAyYCY6AK9YfSRD96/YUSkT6JKUYs9XjG+Q2WG4OfzL18z4qmz10RPP/W2plfO5DwAAAABAVUMSHUCpchmGPt2RpLFrE5Se5zQ7HK8KdlUzOwQ3O+VcypXDuXkavWqXvttz1OxQAAAAAADAeeK35gBKTZojX69s3Ku1VWSBxaOZLqmcTEa3+zETvbzJMwy9t/Wg/knN1kMt6yrQl++tAQAAAACoiPhED6BUbE3N1v0rdlSZBLok7c9yqIa1fMwAt/vZzA4BRVhyKFWjVu7Q3sxcs0MBAAAAAADngCQ6gPP20/4UjVm1S0dy88wOpcxFqLrZIUhiJnp5tzfLrpErd2rJweNmhwIAAAAAAEqIJDqAc+Y0DE3ZelBvbt6vPMMwOxxTZOVYzA5BkuSwMRO9vMt1ujRh0z5N2nJAeS6X2eEAAAAAAIBiIokO4Jxk5jn1zJoEzaviCycmpNsVaPExOwzZbSxxUVHM33tMj6zapcM5DrNDAQAAAAAAxUASHUCJ7c3M1aiVVav+eVGchlTHGmJ2GHKQRK9Qtqfl6IE/d2pXeo7ZoQAAAAAAgLMgiQ6gRNYczdCDf+7UgWxm0Z7ktJufwLb7mB8DSibFnq/Rf+3Ser6MAgAAAACgXCOJDqDYlieladzaRGXlU8/5VInpDvnI3NroDl/zS8qg5LLzXXpmTYKWHko1OxQAAAAAAFAEkugAimXxweN6aeOeKruA6Jlk57sU6xNsagx2H5LoFVWeYWjCxr2al1i11xcAAAAAAKC8IokO4KwW7E/Ra5v2yUn+vEi2fH9Tz+8giV6hGZKmbDuo/24/ZHYoAAAAAADgNCTRAZzRN3uO6u3N+0UBlzM7kJ5v6vntVnPLyaB0fJVwRBM375eLX3wAAAAAAFBukEQHUKSvdh/W+1sPinTe2R2z56u2T5Bp53dYeTmvLP7/Lz/4ywMAAAAAoDwg6wKgUJ/uSNJ//00yO4wKJcRVzbRz2y3MRK9MFh9K1Usb9irfRSIdAAAAAACzkUQHUMCH2w/p812HzQ6jwjmWZV7RGwflXCqd5clpGr8+UQ4nxZQAAAAAADATSXQAboZh6L0tBzQ74YjZoVRI+zIdCrX6mXJuuylnhbf9dSRDz6xNVE4+iXQAAAAAAMxCEh2AJMllGHpr8359t/eY2aFUaFEKNuW8DiaiV1obUjI1dm2CHC4S6QAAAAAAmIEkOgA5XYZe2bhXPx04bnYoFV5Orjkvq3ZKZ1dqm45n6bVN+2Sw2CgAAAAAAGWOJDoAvbF5n5YmpZkdRqWwO82uAPmU+XntIrla2f2WlKap2w6ZHQYAAAAAAFUOSXSgivt0R5IWHUw1O4xKI98wVNcnpMzP62CGcpUwb89RfZXAor8AAAAAAJQlkuhAFfbzgRR9vouEXGlz2X3L/Jx2g3rZVcVH25O06CCllwAAAAAAKCsk0YEqasOxTL29+YDZYVRKe9Idshplu9JnvmHI6VP2ZWRQ9gxJb/69X+uOZpgdCgAAAAAAVQJJdKAK2puZq+fX71E+JUC8IjPfpbq+1cv8vI4A/zI/J8yRbxh6fv0e7UrPMTsUAAAAAAAqPZLoQBVz3J6vZ9YmKjPfaXYolVpAfkCZn9MeUPbnhHmynS49vTZBSdkOs0MBAAAAAKBSI4kOVCF2p0vPrktQUg5JN287lFH2X1I4SKJXOSn2fD21ZrfSHflmhwIAAAAAQKVFEh2oIlyGoVc37dX2NMo/lIXDuXmKslYr03PaKedSJe3Pdmjs2kTZnSwuCwAAAACAN5BEB6qI/24/pOXJ6WaHUaWEGeeXRE/46mv9ctX1+r7LpfrttuE6vnnLGccfdTo1Ytky1Z4+Xf5TpmjpnQN05K/f3f2HFv+g327tqyU3dNf2aa977JuTfEB/3DVA+VmZ5xUzzLE1LVsvbdgjJ+scAAAAAABQ6kiiA1XA/L3HNCfxqNlhVDnHs8993wM/L9I/b72npnffrp4zP1Jok0b6c+QjsqccL3S8Ky9Pt05+X4kZGZpz+eXaPmSIWj84TgERtSRJjrTj2vLOc2py1yNq/+JUHVr8g46sWubef+t7L6vR7Q/KN6jsF0RF6fjzSIambD1odhgAAAAAAFQ6vmYHAMC7/jqSrslbD5gdRpW0N8OuWkE2pbvytGP6Z9r63gdqcPMNajXmwULHp+/are1TP1Lq1u3KOZSk8HZtVG9gf0lSm6ceVfLylfr7tYlK2bRZzuxsxQ7sr1aPjDpxrm9/0LGMDNnznWpds6ZC/PxUs82Fyvu/mck5SfvlG1Rd0T0vlyTVaHuRsvYlKLJTTx1aukBWX19FdetTBvcKvOm7vcfUpkaQLo4OMzsUAAAAAAAqDWaiA5VYQkauXtqwVy4qPJjCkBStEB3/Z6v2zP1OIY0bnnG8M9euanVi1Oz+4ZKk6vVi3X0Wq1Xh7dro4KKlavnQCHWePFH7f/xJSb/9IUlK+m258l2G6gcHq/Hnn6vV//6nnbM+lOE8scBptZg4OXNzlb5zq/Iy0pT+7z+qHt9YeRnp2vXpZDW7/0nv3AkocxM379ehbBYPBgAAAACgtDATHaikHE6XJmzcqxwWGzRVekqO1j3znNo+85j+/WjGGceGt2yu8JbNlXvkROkd3yDPmupWm68sVovq9O0tSYq4sL0yE/dIF3dT2vYdcqSmql50tF7p0kU709J069efKj8/Xw2H3CtbcIhajX5B/7z5jJx2u2r3HqCIDt30z8Rxih0wWDlJB7Rh/ANyOfPVcMh9iupxmXfuEHhdVr5LL2/co4mdGsnXajE7HAAAAAAAKjyS6EAl9eH2Q0rMzDU7jCrvhwnjFNO9myI7XXTWJPrZ2IJDZLgMpW37V4G1o5W6ZavqDewvR3q6HKmpCg8L07RLLpGP1aoOtWppfFwb7Z7ziRoOuVeSVKtbb9Xq1tt9vJRNa5SZsEPN7ntCy+8coNaPvyL/GhH668EhCm/dXn5hNc8rXphne1qOPv73kO5uFmN2KAAAAAAAVHgk0YFK6K8j6fp27zGzw6jykpYuUNrOrbrupS+1RznF3s8vLFSSlJ/luTJpfmamwpo30bpnX5TTblfd/perVtdO2vD8BAVGRyk8IFAXzp6tPJdL4y+6SNW7D5Tj+FG58vJktdk8juVyOLRt8ktq9ejLyj60T4YzXzXaXChJqlYnTmnb/lZk50vO7w6Aqb5OPKp2NaurY2SI2aEAAAAAAFChkUQHKpnj9ny9+fd+s8Oo8nKPJGn7B6+p/csfyNdSXSpBEt1qs8lisylr7z53m+Fy6ejqtYq/8To1vv1Wd/vRteuVvmOXavfqqYSZX+rXAQMUExSkjnPmKCq6kfxqRBZIoEvS7lnTVPPCbgpp1FzpO7e6a6dLksuZL8NFGaCKzpD0+t/7NLVrE9UMKPgcAAAAAAAAxUMSHahk3tq8T8cd+WaHUeWl79giR2qKVo0crFWSZJEMp1PH1m1UwldzddXKxbL4+BS5vy0oSMf//kd75y9QeKvm2v3FV3Lm5Ch2YH9J0rpnX5B/jRo6/MdKXfD8WDlSU7Xrs/9p7u7dGtWmjaICA5UwZ4biBg0rcOzMPbuU/NtP6vzel5KkoNh4WaxWHfhprvzCI5S9L0EhTVp64V5BWUtzOPXKpr169aIGslqojw4AAAAAwLkgiQ5UIt/tOapVRzLMDgOSarTrpC5T5ri34yKlhc8+o+r149Ro6JAzJtAlyScwQDXbt9X2qf+V/ViKQpo0UudJbyqgZg1JUk5SstL/3anILp0U1ryp0rb9q4Bq1bT68GG1mTVLhmGoVs/LFX/jHR7HNQxDW999Xk2Gj5FPwImFS338A9Tykee17f0JcuU51PT+JxUQEVXK9wjMsjElS1/sOqxbGvGYAgAAAABwLkiiA5XEnsxcfbj9kNlh4P/4VgtS9fqN3dt1awXIJzBAfqEhCmnUQNKJ2eQBkZFqMerEwp+uvDxl7E50/7tanRg1uWuYfKoFqnpsXY/jt3litP4a/aSa3XeXJKl6/Tj52Gwa3qKFoqtV06CFC9XszocLJOstFosuerPgAqeRnXoqslPPUrt+lC+f70pWmxpBalOjutmhAAAAAABQ4ZBEByoBh8ulCRv3yu4yzA4FRUjKcBZoy0lKlsVidW/nHjmqZf+53b2967P/addn/1PNDu3Ubdp77nbDMLTxxdfU8uFR8g0MlCT5BPjrlmef0vPjXpDd6dR7F1+seRFRyjN4TkByGdIrG/dpSrfGCvXjv34AAAAAAErCYhhkWICKburWg5q756jZYeAs6kXn64ir+AuMltTFLqtGfzLTvd1/wD0k0eGhU2Swnm9fXxbqowPAGaWnpys0NFRpaWkKCQkxOxwAqDKSBvQwOwQAJoue/3uZnq+47/usRfYAqBDWHs3QPBLoFUINBXn1+A4riVGc2aojGfpmzzGzwwAAAAAAoEIhiQ5UYGmOfL3+9z4x17hiSMvy7vHtJNFRDJ/sSNKRXIfZYQAAAAAAUGGQRAcqsLc271eKPd/sMFBMezLsqm6xee34Dkp0oBhynC59sI1FiAEAAAAAKC6S6EAF9VtSqlYeTjc7DJSAS1Jta7DXjm/32pFR2fyWlKZ1RzPMDgMAAAAAgAqBJDpQAeXkuzSVmaQVkiPXx3vHZiI6SuC9rQeV53KZHQYAAAAAAOUeSXSgApq5K1lHc/PMDgPnICHNLpuXXnrtFMdHCezPsuvrRBYlBgAAAADgbEiiAxXM3sxczSXxVWHZXYZifbxT0sXBErMooS92HdbhHBYZBQAAAADgTEiiAxXM5K0HlW+QLK3IrHl+Xjmu3aA0B0om1+nS1G0HzQ4DAAAAAIByjSQ6UIEsO5Sq9ccyzQ4D52lvep4sXvgexMGXKzgHy5PTteYIi4wCAAAAAFAUkuhABZHrdOmD7SwmWhmkOZyq41v6JV3yDUNOH+8tXIrKa/LWAywyCgAAAABAEUiiAxXEnIQjLCZaiQQ5A7xyXHtgoFeOi8rtQLZDsxOOmB0GAAAAAADlEkl0oAJIseeR4KpkkjOdXjmuI8DfK8dF5fe/3YeVzCKjAMo5p9OpsWPHKj4+XoGBgWrYsKFeeOEFGaeUNDMMQ88++6xq166twMBA9enTRzt27DAxagAAAFR0JNGBCmDGjmTlOCm1UJkcys5ThLX0Z6PbA7wzwx2Vn91p6P2tLDIKoHx79dVXNWXKFL333nvaunWrXn31Vb322muaNGmSe8xrr72md999V1OnTtWqVasUFBSkfv36KTc318TIAQAAUJGRRAfKuYSMHP20P8XsMOAFNVW91I9pZyY6zsPKwywyCqB8W7Fiha6++mr1799f9evX1/XXX6++ffvqr7/+knRiFvrbb7+tZ555RldffbXatGmjTz/9VAcPHtQ333xjbvAAAACosEiiA+XctG2HxBz0yikju/SPafcniY7zM2NnktkhAECRunbtqkWLFunff/+VJG3cuFHLly/XFVdcIUlKSEhQUlKS+vTp494nNDRUnTp10sqVK4s8rt1uV3p6uscNAAAAOMnX7AAAFG31kQytPZZpdhjwkoQMu2oE+irLyC+1Yzr8/UrtWKiatqflaNXhdHWqFWJ2KABQwBNPPKH09HQ1a9ZMPj4+cjqdeumllzRkyBBJUlLSiS8Co6KiPPaLiopy9xVmwoQJeu6557wXOAAAACo0ZqID5diMHcwIrcxchhRjLd1Epd2PJDrO3+e7ks0OAQAK9dVXX2nmzJn64osvtG7dOs2YMUNvvPGGZsyYcV7HffLJJ5WWlua+7du3r5QiBgAAQGXATHSgnNp4LFP/pueYHQa8LC/XR7KV3vEcJNFRCpiNDqC8evTRR/XEE09o8ODBkqTWrVtrz549mjBhgoYOHaro6GhJUnJysmrXru3eLzk5We3atSvyuP7+/vKnJBoAAACKwEx0oJz6KuGI2SGgDCSkO+QrS6kdz24rxYw8qjRmowMoj7Kzs2W1en6E8fHxkct1YgWZ+Ph4RUdHa9GiRe7+9PR0rVq1Sl26dCnTWAEAAFB5MBMdKIcSMnK0+miG2WGgDOQ6XWrgE6IEZ1qpHM9BEh2lhNnoAMqjAQMG6KWXXlK9evXUsmVLrV+/Xm+99ZbuuOMOSZLFYtFDDz2kF198UY0bN1Z8fLzGjh2rmJgYXXPNNeYGDwAAgAqLJDpQDs1mFnqV4pPnV2q/C7LbeFlH6fl8VzJJdADlyqRJkzR27Fjdf//9Onz4sGJiYnTPPffo2WefdY957LHHlJWVpbvvvlupqanq3r27Fi5cqICAABMjBwAAQEVmMQzDMDsIAP/f4RyHhv22Xfn8aVYZ4X6+yg09rtKo6jL0eKaumzdfktR/wD3K43mE8/T6RQ3UtmZ1s8MAgDKVnp6u0NBQpaWlKSSELxMBoKwkDehhdggATBY9//cyPV9x3/dREx0oZ+YmHiWBXsUcd+Qrxrd0kpR2X2aio3SxPgMAAAAAoKojiQ6UI5l5Ti3Yn2J2GDBBsDOwVI7j8PUpleMAJ60+mqGEjByzwwAAAAAAwDQk0YFyZP7eY8pxuswOAyY4klU6j7vdh5d1lD5mowMAAAAAqjKyLUA54XC59O3eo2aHAZMcyHKohtX/vI9jtzITHaVv6aFUHc5xmB0GAAAAAACmIIkOlBO/HjiuFHu+2WHARJE6/7roDisv6yh9TkP6OpEv+QAAAAAAVRPZFqAccBmG5lAuocrLzLGc9zHs1vM/BlCYhftTlJNPuSkAAAAAQNVDEh0oB1YcTtf+bEolVHUJ6XYFWs6vHAtJdHhLjtOlP5LTzA4DAAAAAIAyRxIdKAeYhQ7pRMmMOtaQ8zqGw0ISHd7zy8HjZocAAAAAAECZI4kOmGxfZq62pGabHQbKCafd97z2t5dSHEBhNh7LZIFRAAAAAECVQxIdMNmSQ6lmh4ByJDHdIR+d+2xyBxPR4UUuSYsOppodBgAAAAAAZYokOmAykug4VXa+S7E+517SxW6UYjBAIX45kGJ2CAAAAAAAlCmS6ICJtqdl6wALiuI0tny/c97XIbLo8K792Q5tTc0yOwwAAAAAAMoMSXTARIspi4BCHEjPP+d97YarFCMBCvfLgVSzQwAAAAAAoMyQRAdM4jIMLUtKNTsMlEPH7PmK9gk6p30dLmaiw/uWJaXK4eILGwAAAABA1UASHTDJxpRMpdjPfcYxKrdQV7Vz2s8pQ/k+PqUcDeApI8+pPw+nmx0GAAAAAABlgiQ6YBJKueBMjmWd+yxfR2BgKUYCFO6XA8fNDgEAAAAAgDJBEh0wgcPl0h/JzOJE0fZlOhRmObcFRu0BAaUcDVDQmqMZOs6vaQAAAAAAVQBJdMAEfx3JUGa+0+wwUM7VsgSf0372QJLo8D6nIS0+xGx0AAAAAEDlRxIdMMESSrmgGLJzz+0l2hHgX8qRAIX7lZIuAAAAAIAqgCQ6UMay851adYRSLji7hDS7AlTyRULt/iTRUTZ2ZeRqb2au2WEAAAAAAOBVJNGBMrY8OU0Ol2F2GKgA8g1DdX1KXtLF4X9utdSBc7HmaIbZIQAAAAAA4FUk0YEytvRQqtkhoAJxOWwl3sfuRxIdZWf9sUyzQwAAAAAAwKtIogNlKNfp0sZjWWaHgQpkT5pDVsNSon1IoqMsbUrJUj6/rgEAAAAAVGIk0YEytOV4lvIMkk0ovsx8l2J9S1bSxW4r+ex14FzlOF3ampptdhgAAAAAAHgNSXSgDG1MYRY6Ss4/v2QLhTpIoqOMrTtGXXQAAAAAQOVFEh0oQ5tSqB2MkjuY4SzReLvN10uRAIWjLjoAAAAAoDIjiQ6UkVynS/+m5ZgdBiqgI7l5irJWK/Z4hy9JdJStbWnZysov2Zc9AAAAAABUFCTRgTJCPXScjzCj+El0u6+PFyMBCnIZ0kZmowMAAAAAKimS6EAZoR46zsfxrOJ/AePwIYmOskdJFwAAAABAZUUSHSgj1EPH+dib6VCItXgLhtpJosMEa0miAwAAAAAqKZLoQBmgHjrOlyEp2hJcrLEOH17aUfb2Z9l1JNdhdhgAAAAAAJQ6Mi1AGaAeOkpDbk7xZpjbrby0wxzrjjIbHQAAAABQ+ZBpAcoA9dBRGnan2+VfjJdtB0l0mGQdJV0AAAAAAJUQmRagDFAPHaUhz2Work/oWcfZLWUQDFCI9ccyZfCrGwAAAABAJUMSHfAy6qGjVDl8zz7EQhYd5kh15CspJ8/sMAAAAAAAKFUk0QEvox46StOe9DxZzvJ0spdNKECh9mTmmh0CAAAAAACliiQ64GV/H6ceOkpPRp5TdX2DzziGci4wUyJJdAAAAABAJUMSHfCy3RkklFC6Ap0BZ+x38MsHmIiZ6AAAAACAyoYkOuBlJJRQ2pIynGfsp5wLzMRrHgAAAACgsiGJDniR3elSUrbD7DBQySTn5KmWT2CR/XbDVYbRAJ72Ztrl4tcQAAAAAIBKhCQ64EV7M3NFOhPeEO4KKrLP4eJZB/M4XIYO8eUhAAAAAKASIYkOeNGeTAprwDtSs4vuc0nKs9nKLBbgdAmUdAEAAAAAVCIk0QEvojYwvGVvhl3BlqIT5fbAosu9AN7Gax8AAAAAoDIhiQ54USKJJHiJS1Jta3CR/Y4A/7ILBjhNYgavfQAAAACAyoMkOuBF+7Mo5wLvsef6FN0XEFCGkQCeKGUFAAAAAKhMSKIDXuI0DCXn5JkdBiqx3Wl22Yp4GXf4MxMd5jmQZZfTZZgdBgAAAAAApYIkOuAlR3LylG+QRIL3OFyGYn1CCu2zU84FJsozDO3PZjY6AAAAAKByIIkOeMmhHBJI8D5rXuGLizr8/Mo4EsATi4sCAAAAACoLkuiAlxzMdpgdAqqAvWl5shTygwe7P0l0mIvFRQEAAAAAlQVJdMBLDpFERxlIy3Oqjm9wgXaHrfAZ6kBZOZzLmhAAAAAAgMqBJDrgJcxER1kJcgYUaLP7kUSHuY7b880OAUAZatCggY4dO1agPTU1VQ0aNDAhIgAAAKD0kEQHvCQphyQ6ykZyprNAm8OXJDrMddxBEh2oShITE+V0Fvz/yG6368CBAyZEBAAAAJQeX7MDACqrjDwSSCgbh7LzFBsSoKOu/1+D2m7zlQqplQ6UlVRmogNVwnfffef+908//aTQ0FD3ttPp1KJFi1S/fn0TIgMAAABKD0l0wEuy811mh4AqpKaq66hOSaL7+kqUpIaJUh35MgxDFovF7FAAeNE111wjSbJYLBo6dKhHn81mU/369fXmm2+aEBkAAABQekiiA16SlV/wJ82At6RnSzqlNDpJdJgt3zCUkedUiB9vNYDKzOU6MWkgPj5eq1evVkREhMkRAQAAAKWPT7aAF+Tku+SilAbKUGKGXTUDfZVpnCih4fBhyQuYL9WRTxIdqCISEhLMDgEAAADwGj7ZAl6QzSx0lDGXIcVYQ/SvM0WSZPfxMTki4EQSvZ7ZQQAoM4sWLdKiRYt0+PBh9wz1kz7++GOTogIAAADOH0l0wAso5QIzOHJ9JNv//ZuZ6CgHMvN4LQSqiueee07PP/+8LrzwQtWuXZv1EAAAAFCpkEQHvIAkOsyQkO6QraZF+TJkt5JEh/myWGAZqDKmTp2qTz75RLfeeqvXz3XgwAE9/vjjWrBggbKzs9WoUSNNnz5dF154oSTJMAyNGzdOH374oVJTU9WtWzdNmTJFjRs39npsAAAAqJzIsgBeQOIIZsh1uhTrEyJJcpBERznAF4pA1eFwONS1a1evn+f48ePq1q2bbDabFixYoC1btujNN99UeHi4e8xrr72md999V1OnTtWqVasUFBSkfv36KTc31+vxAQAAoHIiywJ4ATXRYRafPD9Jkp1f0aMcIIkOVB133XWXvvjiC6+f59VXX1VsbKymT5+ujh07Kj4+Xn379lXDhg0lnZiF/vbbb+uZZ57R1VdfrTZt2ujTTz/VwYMH9c0333g9PgAAAFROlHMBvCCLOsAwyf70fClUclCLFuUAr4VA1ZGbm6tp06bp119/VZs2bWSz2Tz633rrrVI5z3fffad+/frphhtu0LJly1SnTh3df//9Gj58uCQpISFBSUlJ6tOnj3uf0NBQderUSStXrtTgwYMLPa7dbpfdbndvp6enl0q8AAAAqBxIogNeQDkXmOW4I1+NfKvLbrGffTDgZbwWAlXHpk2b1K5dO0nS5s2bPfpKc5HR3bt3a8qUKXrkkUf01FNPafXq1XrggQfk5+enoUOHKikpSZIUFRXlsV9UVJS7rzATJkzQc889V2pxAgAAoHIhiQ54AeVcYKbqzkBl+ZJEh/l4LQSqjiVLlpTJeVwuly688EK9/PLLkqQLLrhAmzdv1tSpUzV06NBzPu6TTz6pRx55xL2dnp6u2NjY844XAAAAlQM10QEvYPYlzHQ4yyW7YZgdBiAnz0MApax27dpq0aKFR1vz5s21d+9eSVJ0dLQkKTk52WNMcnKyu68w/v7+CgkJ8bgBAAAAJzETHfACFtODmQ5mOdQs1M/sMAD5UJsfqDJ69ep1xrItixcvLpXzdOvWTdu3b/do+/fffxUXFydJio+PV3R0tBYtWuQuL5Oenq5Vq1bpvvvuK5UYAAAAUPWQRAe8IJuZ6DBZdWegpDyzw0AVRxIdqDpOJqxPysvL04YNG7R58+bzKrNyuocfflhdu3bVyy+/rBtvvFF//fWXpk2bpmnTpkk6UX/9oYce0osvvqjGjRsrPj5eY8eOVUxMjK655ppSiwMAAABVC0l0wAt8yBvBZKk5PAlhPl8rz0Ogqpg4cWKh7ePHj1dmZmapneeiiy7SvHnz9OSTT+r5559XfHy83n77bQ0ZMsQ95rHHHlNWVpbuvvtupaamqnv37lq4cKECAgJKLQ4AAABULRbDoGApUNre+Huffj5w3OwwUIX5WCTDkPhNBMx0Rd0aerhVXbPDAGCinTt3qmPHjkpJSTE7lBJJT09XaGio0tLSqI8OAGUoaUAPs0MAYLLo+b+X6fmK+76PmeiAF/hZWbMX5nLy9SjKAWaiA1i5ciUzwAEAAFDhkUQHvMCfei4AIF9qogNVxnXXXeexbRiGDh06pDVr1mjs2LEmRQUAAACUDpLogBcwEx0AWB8CqEpCQ0M9tq1Wq5o2barnn39effv2NSkqAAAAoHSQRAe8gJnoAEA5F6AqmT59utkhAAAAAF5DEh3wAn8fZqIDAOVcgKpn7dq12rp1qySpZcuWuuCCC0yOqGJpu/YRs0MAYLKNHd4yOwQAQCFIogNe4E85FwCQDzPRgSrj8OHDGjx4sJYuXaqwsDBJUmpqqnr16qVZs2YpMjLS3AABAACA80CmD/ACP8q5AIB8mIkOVBmjRo1SRkaG/vnnH6WkpCglJUWbN29Wenq6HnjgAbPDAwAAAM4LM9EBL2AmOgBQzgWoShYuXKhff/1VzZs3d7e1aNFCkydPZmFRAAAAVHhk+gAv8KMmOgAwEx2oQlwul2w2W4F2m80ml8tlQkQAAABA6SHTB3hBAOVcAEC+1EQHqoxLL71UDz74oA4ePOhuO3DggB5++GH17t3bxMgAAACA80cSHfACP8q5AICCfHktBKqK9957T+np6apfv74aNmyohg0bKj4+Xunp6Zo0aZLZ4QEAAADnhZrogBf4U84FABQZ4Gd2CADKSGxsrNatW6dff/1V27ZtkyQ1b95cffr0MTkyAAAA4PyR6QO8wJ8SBgCgyICC9ZEBVC6LFy9WixYtlJ6eLovFossuu0yjRo3SqFGjdNFFF6lly5b6/fffzQ4TAAAAOC8k0QEvqEniCEAVZ5UUwWshUOm9/fbbGj58uEJCQgr0hYaG6p577tFbb71lQmQAAABA6SGJDnhBNV8fhdh8zA4DAEwT5u/LwqJAFbBx40ZdfvnlRfb37dtXa9euLcOIAAAAgNJHEh3wkuhAagEDqLoo5QJUDcnJybLZiv579/X11ZEjR8owIgAAAKD0kUQHvKR2NZLoAKouFhUFqoY6depo8+bNRfZv2rRJtWvXLsOIAAAAgNJHEh3wEmaiA6jKmIkOVA1XXnmlxo4dq9zc3AJ9OTk5GjdunK666ioTIgMAAABKj6/ZAQCVVRRJdABVGEl0oGp45plnNHfuXDVp0kQjR45U06ZNJUnbtm3T5MmT5XQ69fTTT5scJQAAAHB+SKIDXkI5FwBVWa1AkuhAVRAVFaUVK1bovvvu05NPPinDMCRJFotF/fr10+TJkxUVFWVylAAAAMD5IYkOeAnlXABUZcxEB6qOuLg4/fjjjzp+/Lh27twpwzDUuHFjhYeHmx0aAAAAUCpIogNeEhXoJ6skl9mBAIAJWFgUqHrCw8N10UUXmR0GAAAAUOpYWBTwEl+rRRHMxARQBflYpBr+fE8PAAAAAKgcSKIDXkRJFwBVUU1/m6wWi9lhAAAAAABQKkiiA14UzeKiAKog6qEDAAAAACoTkuiAFzETHUBVVDfI3+wQAAAAAAAoNSTRAS9iJjqAqqhpaDWzQwAAAAAAoNSQRAe8qDYz0QFUQU1DA80OAQAAAACAUkMSHfCi+OAA/sgAVCl+VosaBJNEBwAAAABUHuT3AC+q5uuj2OrUBgZQdTQMDpSP1WJ2GAAAAAAAlBqS6ICXURsYQFXSNIxZ6AAAAACAyoUkOuBlJNEBVCVNeM0DAAAAAFQyJNEBL2OBPQBVSTOS6AAAAACASoYkOuBlDYID5Ud9YABVQHVfH9Wp5md2GAAAAAAAlCqS6ICX+VotahjMbHQAlV/j0EBZLHxpCAAAAACoXEiiA2WgRTjlDQBUfpSvAgAAAABURiTRgTLQKjzI7BAAwOtYSBkAAAAAUBmRRAfKQOvwIFHgAEBlRxIdAAAAAFAZkUQHykCIn6/iqgeYHQYAeE1Nf19FBNjMDgMAAAAAgFJHEh0oI61rUNIFQOXVhFnoAAAAAIBKiiQ6UEZaUxcdQCV2Qc3qZocAAAAAAIBXkEQHykgbZqIDqMQ6RQabHQIAAAAAAF5BEh0oIzX8bYoN8jc7DAAodbFB/qpdjdc3AAAAAEDlRBIdKENda4WYHQIAlDpmoQMAAAAAKjOS6EAZ6hEdanYIAFDqOkbyBSEAAAAAoPIiiQ6UoSah1RQd6Gd2GABQaqr5WtWKhZMBAAAAAJUYSXSgjHWPYsYmgMqjfc1g+VotZocBAAAAAIDXkEQHyhglXQBUJl1Y6wEAAAAAUMmRRAfKWLPQaooMsJkdBgCcN1+LhSQ6AAAAAKDSI4kOlDGLxaLuUcxGB1DxtatZXdVtPmaHAQAAAACAV5FEB0xASRcAlUEP1ngAAAAAAFQBJNEBE7QMq6aa/r5mhwEA58xqkbryqxoAAAAAQBVAEh0wgcViUTeSTwAqsDbh1RXqx5eBAAAAAIDKjyQ6YJIeJNEBVGDdoynlAgAAAACoGkiiAyZpXSNIYcziBFAB+VosfBEIAAAAAKgySKIDJrFaLOrGonwAKqBuUSEK97eZHQYAAAAAAGWCJDpgImZyAqiIBtSraXYIAAAAAACUGZLogIna1ayu2oF+ZocBAMVWv3qA2tSobnYYAAAAAACUGZLogImsFosGxjGjE0DFcVW9GmaHAABur7zyiiwWix566CF3W25urkaMGKGaNWuqevXqGjRokJKTk80LEgAAABUeSXTAZJfXraFqPvwpAij/qvlY1Scm3OwwAECStHr1an3wwQdq06aNR/vDDz+s+fPna/bs2Vq2bJkOHjyo6667zqQoAQAAUBmQuQNMFuTro8vqkJQCUP71rhOuar4+ZocBAMrMzNSQIUP04YcfKjz8/7+PSktL00cffaS33npLl156qTp06KDp06drxYoV+vPPP02MGAAAABUZSXSgHLgmLkIWs4MAgLMYEEv5KQDlw4gRI9S/f3/16dPHo33t2rXKy8vzaG/WrJnq1aunlStXlnWYAAAAqCR8zQ4AgFQnyF8dI4O16kiG2aEAQKFahwepfnCA2WEAgGbNmqV169Zp9erVBfqSkpLk5+ensLAwj/aoqCglJSUVeUy73S673e7eTk9PL7V4AQAAUPExEx0oJ66NizA7BAAo0sB6zEIHYL59+/bpwQcf1MyZMxUQUHpf7E2YMEGhoaHuW2xsbKkdGwAAABUfSXSgnGgfEay46v5mhwEABdTw91W3qFCzwwAArV27VocPH1b79u3l6+srX19fLVu2TO+++658fX0VFRUlh8Oh1NRUj/2Sk5MVHR1d5HGffPJJpaWluW/79u3z8pUAAACgIqGcC1COXBMXoXf+OWB2GADg4Yq6NeRrZeUGAObr3bu3/v77b4+222+/Xc2aNdPjjz+u2NhY2Ww2LVq0SIMGDZIkbd++XXv37lWXLl2KPK6/v7/8/ZnMAAAAgMKRRAfKkT4x4fr43yRl5DnNDgUAJEk+Fqk/C4oCKCeCg4PVqlUrj7agoCDVrFnT3X7nnXfqkUceUY0aNRQSEqJRo0apS5cu6ty5sxkhAwAAoBIgiQ6UI/4+Vl1Zt4a+TDhidigAIEnqUitEEQE2s8MAgGKbOHGirFarBg0aJLvdrn79+un99983OywAAABUYCTRgXJmYFxNzUk8IqdhdiQAIF1XP9LsEADgjJYuXeqxHRAQoMmTJ2vy5MnmBAQAAIBKh4VFgXImMsBP3VnAD0A5cFFEsFqFB5kdBgAAAAAApiKJDpRD19WPMDsEAFWcRdIdTaLNDgMAAAAAANORRAfKoeZhQeoUGWx2GACqsJ7RoWoYEmh2GAAAAAAAmI4kOlBO3dW0tqwWs6MAUBX5WKShjZmFDgAAAACARBIdKLfiqgeoX50aZocBoAq6vG4N1QnyNzsMAAAAAADKBZLoQDk2tHGUAnz4MwVQdvytFt3SMMrsMAAAAAAAKDfIzgHlWA1/m65nkVEAZejquAjVDLCZHQYAAAAAAOUGSXSgnLshvpZq+PuaHQaAKqC6r49uahBpdhgAAAAAAJQrJNGBci7Q16pbG1FaAYD33RAfqWAbX9oBAAAAAHAqkuhABXB53RqKq84ifwC8p4a/r66Jo3wUAAAAAACnI4kOVAA+FovubFLb7DAAVGL/aVBLgb68LQAAAAAA4HR8WgYqiM61QtS2RpDZYQCohKID/XRlbE2zwwAAAAAAoFwiiQ5UIHc3rS2L2UEAqHSGNY6Sr5VXFwAAAAAACkMSHahAGodWU6/aYWaHAaAS6VCzui6NCTc7DAAAAAAAyi2S6EAFc3uTaNmYMQqgFAT6WPVQq7pmhwEAAAAAQLlGEh2oYKIC/XRzg1pmhwGgErizSbSiAv3MDgMAAAAAgHKNJDpQAd3coJYaBgeYHQaACqx1eJAG1GMxUQAAAAAAzoYkOlAB+VgtGt06Vj5UdQFwDvytFj3Sqq4sFl5EAAAAAAA4G5LoQAXVKCRQN8ZT1gVAyQ1tHK06Qf5mhwEAAAAAQIVAEh2owG5pVEtx1UmEASi+ZqHVdF39CLPDAAAAAACgwvA1OwAA585mtWp0q1g9tGqnXIbZ0cAs+dlZ2vXpZB1euViO1BQFN2ympvc8ptCmrSRJm98cq0O/fuexT80OXdX+xSlFHnPf919p/w9fKSf5oCSpelxDNfjPPYq4qLt7zPZpr+vgL9/JJyBQjW9/ULUv7e/uS/79Zx38db4ueG5SaV4qzpPNYtHo1nVlpYwLAAAAAADFRhIdqOCahVXT9fUj9VXCEbNDgUm2vDNemYk71WrMS/KvGalDi3/QuqfuUZcP5iogIkqSVPPCbmr58PPufaw2vzMeMyCilhrd/qCq1aknGYYO/TpfG55/UJ3f+1LV4xrpyJ9LlbR0gdq/NFXZB/dqy8Rxqtmhq/xCw5WXlaGdMyap/cvTvHrdKLn/NKqluOosSgwAAAAAQElQzgWoBIY2jlLDYBJjVZHTnqvDyxep8Z0PK7x1B1WLqaeGt9ynwJhY7f9htnuc1eYn/xoR7pstOOSMx43sfIkiO/ZQUJ04BdWtr0bDRsknoJrStm2SJGXtS1B46wsV2qSlal9yhXyrBSkn6YAkacdHE1W3/40KrFXbexeOEmsYHKDBrKMAAAAAAECJkUQHKgGb1aon2taTn5USDVWN4XTKcDlltXnWxvfx81fqP+vd28c3rdHSwZfoj7sGauukF+VITy3ROZKWLpAzN0ehzdpKkqo3aKL0HVuUl5Gu9B1b5LTbVS2mno5vXqeMndtUb+B/SuX6UDp8LNKY1rHy4TUCAAAAAIASo5wLUEnEVQ/QnU1qa8q2g2aHgjLkWy1Ioc3bKuF/0xRUL17+YTWVtGyBUrdtUrXasZKkiA5dVatbbwVG1VHOoX3a+ckkrR97vzq+9ZksPj5FHjsjYYdWP3KrXA6HfAKrqe3Yiaoe1/D/jtlNtS/tr1UP/kc+/v5qNfoF+QQEatvkl9TykRe074evtO+7/8kWGq4WD4xV9bhGZXJ/oHA3xtdSw5BAs8MAAAAAAKBCIokOVCLXxNXU6qPpWnM00+xQUIZajXlJ/0wcp99vuUwWq4+CGzVTdM/LlbFzqyQp+pIr3GOD4xurenwT/XFHf6VsWqOaF3Qq8rhBdeur8+SvlJ+VqeTlv+ifN8fqwtc+cifSG95ynxrecp97/K6ZU1WjXWdZfH2VMOtDdXl/jo789Zs2v/GMOk+a5aWrx9k0CgnQkEaUcQEAAAAA4FxRzgWoRCwWi0a3ilWIrejZxah8qsXE6qLXP9al81aqx2c/qdM7X8hw5iswum7h42vXlS0kXDmH9p7xuFabTdVi6imkcQs1vv1BBTdoor3fzix0bNa+BB1a/IMa3jZCxzetVnirDvILq6Hoi/sqY+dW5Wdnnfd1ouSCbT4a266+/Kz8dw8AAAAAwLniUzVQydQMsOmRVnVF5eOqxyegmvxrRCovI13H1q5UZOdLCh2XeyRZeRmp8qsRWaLjG4ZLrry8QtoNbXn3BTUdPlq+gdVkuFxy5Z8Y58rPPzHG5SzZxeC8WSQ92jpWtav5mR0KAAAAAAAVGkl0oBLqGhWqWxpFmR0GysjRtX/o6Jo/lJO0X8fWrdSaJ+5SUN36iul7tfJzsvXvf99S6tZNykk+oGPrV2nD8w+qWkysItp3dR9j7RPDtfe7/7m3d0x/R8f/Xquc5APKSNhxYnvTGtXudWWB8x9YOFd+oeHupH1Yi3Y6vnG1Urdu0t55nyuoXgPZqod4/X6Ap8ENav0/9u47TKry7h/wZ5eylGWXIlUREAsiYO8FC4rGRjS22KPRGDVRfGPimyiKLXajYolRNLHGxJKYqEFssXejsUSNXcAKKEoRzu8Pf8zruowgAoNw39c1l8xznnPO95wdZ8989pnnZJ1OzjsAAAB8U+ZEh0XUHr075fWPJ+fusRMqXQrz2WeTPs5LI8/J5PfGpVmb+nTeYLP03vvQVDdtlmL69Hz8yn/y9u1/yWeTPkpN+07psNq66b3Xwalu/n8jlD8Z82amTRxfej51/Ad55vRfZcoH76Zp69q06bV8VjvhgnRYbd0G+57y4ft55ZrfZc0zLy+11a/QP0vvsGeeHHZImrdtn5WOOH6+nwMaWrVDbfZezh/SAAAAYF6oKoqiqHQRwPwxZfqMHP7Qy3lp4qeVLgVYQDq2aJbz11su9c39nRxgbk2cODH19fWZMGFC6uoW3Ld6Vn5s6ALbF7Bwemr1MytdQkWN3XbDSpcAVFiXv/5zge5vTq/7TOcCi7CaJtU5brUeaV8jTIPFQfPqqhy9Sg8BOgAAAMxDQnRYxHVs0TzDVu2Z5tVuNQqLusP6LZU+bVtVugwAAABYpAjRYTGwYttWOazfUpUuA5iPdu7VMYO6tat0GQAAALDIEaLDYmJQt3bZpVfHSpcBzAdrd2yTHyzfpdJlAAAAwCJJiA6LkX2X75J1OrapdBnAPNSjtiZHrbx0qqtM2QQAAADzgxAdFiPVVVX5xcpLp2dti0qXAswDbZo1yXGr9Uyrpk0qXQoAAAAssoTosJhp1fTz0K2+mdANvs1aNKnO8NV6plurmkqXAgAAAIs0IToshrq2ap6jV+2RpqZ/gG+l5tVVOW61nlmpXetKlwIAAACLPCE6LKYGtK/Nz/ovlWo5OnyrNKuqyrBVe2bVDrWVLgUAAAAWC0J0WIxt0q1dfta/uyAdviWaVCX/u8rSWdMNggEAAGCBEaLDYm6zmUF6pQsBvlJ1kiMHLJ31O9dXuhQAAABYrMjNgM+D9AGCdFhYVSUZ2n+pbNK1baVLAQAAgMWOzAxI8nmQ/j+CdFgoHdp3yWyxZPtKlwEAAACLJXkZUDJIkA4LnR/16Zptlu5Q6TIAAABgsSUrAxoY1K1d/scc6bBQ2He5LtmhZ8dKlwEAAACLNTkZ0MigJQXpUGm79+6U3Xp3qnQZAAAAsNiTkQGzNGjJdjlCkA4V8b2eS2Tv5bpUugwAAAAgSdNKFwAsvDZfsl2S5Iyn38iMCtcCi4u9lu2cPZbtXOkyAAAAgP9PiA58pc2XbJciRc58+k1BOsxHzaqrckS/pbJpt3aVLgUAAAD4AiE6MFtbLNk+bZs3zUlPvZ5PPhOlw7xW16xJjl2tZ/q1a13pUgAAAIAvMd0xMEfW6liX36yzbLq2bF7pUmCRsmSr5vnNOssK0AEAAGAhJUQH5liP2hY5d91lM0DYB/NEv3at85t1ls2SrWsqXQoAAABQhhAd+FrqmjfNr9dcJlst1b7SpcC32mbd2uaUNXulrrmZ1QAAAGBhJkQHvram1VU5vN9SOahPt1RXVboa+PbZo3en/HzA0mlW7dcwAAAALOwMfwPm2nd7LpHurWty4lOvZZIbjsJsNav6/A9Qg5ZsV+lSAAAAgDlkCBzwjazRsU1+s86y6dbKDUfhq7Rp1iQnr9lLgA4AAADfMkJ04BtburZFzlln2azSvrbSpcBCqVur5vnNOstmgP9HAAAA4FtHiA7ME3XNm+bkNXplm+4dKl0KLFQGdWubEestl6Va11S6FAAAAGAuCNGBeaZJdVV+stKS+UnfJdPcHUdZzNU2bZL/XXnpHDlg6bRu2qTS5QAsMk4++eSsueaaadOmTTp16pQhQ4bkhRdeaNBn8uTJOfjgg9OhQ4fU1tZmxx13zLhx4ypUMQAA33ZCdGCe22bpDjl33eWyTJsWlS4FKmLl9q1z4frLZeOubStdCsAi5+67787BBx+cBx98MKNGjcq0adOyxRZbZNKkSaU+hx9+eP7617/muuuuy91335233347O+ywQwWrBgDg26xppQsAFk292rTIOesum5H/GZvrX30vRaULggWgaVVV9l6uc3bq1THVVb6NATA/3HrrrQ2eX3bZZenUqVMee+yxbLTRRpkwYUIuueSSXHXVVdl0002TJCNHjsyKK66YBx98MOuss04lygYA4FvMSHRgvmleXZ0D+3TLyWv0yhI1zSpdDsxXS7Wuydnr9M4uy3QSoAMsQBMmTEiStG/fPkny2GOPZdq0aRk0aFCpT58+fbL00kvngQcemOU2pkyZkokTJzZ4AADATEJ0YL5bbYk2uXD95bJh5/pKlwLzxTbd2+f89ZbL8vWtKl0KwGJlxowZOeyww7L++uunX79+SZKxY8emefPmadu2bYO+nTt3ztixY2e5nZNPPjn19fWlR/fu3ed36QAAfIsI0YEFoq550xy9ao8ctfLSqW/mJossGuqbN8lxq/XMT1ZaKi2a+JUKsKAdfPDBeeaZZ3LNNdd8o+0cddRRmTBhQunxxhtvzKMKAQBYFJgTHVigNunaNqu0r815z76Vf46bUOlyYK6tsUSb/Kz/UmlnqiKAijjkkENy880355577slSSy1Vau/SpUumTp2a8ePHNxiNPm7cuHTp0mWW26qpqUlNTc38LhkAgG8pw+aABa5dzeej0n+1ytJp29zf8vh2admkOgev2C0nrt5TgA5QAUVR5JBDDskNN9yQO+64I7169WqwfPXVV0+zZs0yevToUtsLL7yQ119/Peuuu+6CLhcAgEWA9AqomI26fD4qfcRzb+fOMeMrXQ7M1iZd2+aAFbqmQwvhOUClHHzwwbnqqqty0003pU2bNqV5zuvr69OyZcvU19dnv/32y9ChQ9O+ffvU1dXl0EMPzbrrrpt11lmnwtUDAPBtJEQHKqquedMctfLSGbxku/z2hTH570eTK10SNNKztkUO6dstA9rXVroUgMXeBRdckCTZeOONG7SPHDky++yzT5LkrLPOSnV1dXbcccdMmTIlgwcPzvnnn7+AKwUAYFEhRAcWCqst0Sbnd6jN7W99mMteHJf3pkyrdEmQVk2rs+eynTNk6SXSpLqq0uUAkM+nc5mdFi1aZMSIERkxYsQCqAgAgEWdEB1YaFRXVWWLpdpno65t8+dX380f//tuPp0+o9JlsRiqTrJZt3bZb4UuaW/ecwAAAFisCdGBhU6LJtXZvXfnfGep9vn9S+Nyy5sfZMbsB53BPLFK+9oc0Kdrlq1rWelSAAAAgIWAEB1YaLWraZafrrRUvttjiVz8wpg89O5HlS6JRViP2prsv3zXrN2prtKlAAAAAAsRITqw0Fu6tkWOX71Xnnz/4/z2hTF5aeKnlS6JRUi75k2z57Kds1X39mlSZd5zAAAAoCEhOvCtsUqH2oxYd9mMfnt8Rr44Nu9OdvNR5t4SLZrluz2WyDbd26dl0yaVLgcAAABYSAnRgW+VqqqqDFqyXTbqUp+/vP5+bnrtvYwTpvM19Kptke/16phNurZN02ojzwEAAICvJkQHvpWaN6nO93p1zHd7LpH7xk3IDa++l3+P/6TSZbEQW6V9bXbq1TFrdmxT6VIAAACAbxEhOvCt1qSqKht1aZuNurTNfyZ8kutffS/3jJ2Qz4qi0qWxEKiuSjbsXJ+denXM8vWtKl0OAAAA8C0kRAcWGcvXt8ovVl46P1xhWv7y+vv5+xvvZ8K06ZUuiwqoaVKVLZdsnx16dkzXVs0rXQ4AAADwLSZEBxY5HVo0y77Ld8n3e3fK6Lc/zA2vvZfXPp5S6bJYANo2b5rte3TItt07pK65X3EAAADANydhABZZNU2q853uHfKd7h3y2Hsf5YbX3ssj734UE70sWqqSrNSuVQZ1a5dB3dqleZPqSpcEAAAALEKE6MBiYfUl2mT1JdrkzUlT8vc33s8/x03IuE+nVbosvoHebVpkk65ts3HXtunU0pQtAAAAwPwhRAcWK0u1rskBfbrlgD7d8sKET/LPsRNyz9gJGfvp1EqXxhzo1qp5NunaNpt0bZula1tUuhwAAABgMSBEBxZbK9S3ygr1rbL/Cl3z4oRPcs/YCfnnuAl5+xOB+sKkQ03TDOzSNpt0a5sV6ltVuhwAAABgMSNEB0iyXH2rLFffKvut0DUvT/z080B97Pi8KVCviDbNmmSDzvXZpGvbDGjfOtVVVZUuCQAAAFhMCdEBvqR3Xcv0rmuZfZfvklc++jxQv2fshLwxaUqlS1uk9aitSf92tVmzY5ussURtmlW7QSgAAABQeUJ0gK/Qq03L9GrTMnsv1yWvfzw5T77/cZ7+cFL+9cGkfDj1s0qX961VlaRnbYsMaN86/du3zoD2tWnb3K8kAAAAYOEjsQCYQ0vXtsjStS2yXY8lkiRvfDw5//r/gfrTH0zKe1OmVbjChVd1kl5tWmRA+9rPg/N2rVMnNAcAAAC+BSQYAHOpe22LdK9tka27d0iSvPPp1Dw/4ZM8P/6TPD/h07w08dNMnj6jwlVWRnVV0rtNywz4/6PM+7drndpmTSpdFgAAAMDXJkQHmEc6tWyeTi2bZ6MubZMk04sir340OS9M+CQvTfw0b38yNWM/nZp3Pp2Wz4qissXOQ51aNEuP2hbpUVuTHv9/tH7P2pq0bCo0BwAAAL79hOgA80mTqqrSTUq/aHpR5N1Pp2XMp1Mz9pMpGfPp1Iz5/wH7mE+mZuK06RWqeNaqkrSraZpurZqnS8uadG3VPF1bNs9SrWuydG1NWgnLAQAAgEWYEB1gAWtSVZUurZqnS6vmSYfaRssnfTY9Yz/5PFAf8+nUvDd5WiZPn5Ep02dkyozP/zt5epGp///558uK0vIZZQa511RXpVXTJmnVtLrBf1uX/ttwWZtmTdK5ZfN0adk8NU2q5/NZAQAAAFg4CdEBFjKtmzaZ5Qj2OTVtxv+F6p8VRVo2+TwYb1pdNY8rBQAAAFj0CdEBFjHNqqvTrDpu5AkAAAAwD/h+PgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAFlk9e/bM2WefXekyAAAAgG8xIToA88Q+++yTqqqqRo+XXnppvu/7sssuS9u2bRu1P/LIIznggAPm+/4BAACARVfTShcAwKJjyy23zMiRIxu0dezYsULVVHbfAAAAwKLBSHQA5pmampp06dKlwWO//fbLkCFDGvQ77LDDsvHGG5eeb7zxxvnJT36SI488Mu3bt0+XLl1y7LHHNlhn/PjxOfDAA9O5c+e0aNEi/fr1y80335y77ror++67byZMmFAa/T5z3S9P5/L6669n++23T21tberq6rLzzjtn3LhxpeXHHntsVllllfzhD39Iz549U19fn1133TUfffRRqc+f/vSn9O/fPy1btkyHDh0yaNCgTJo0aV6dQgAAAGAhI0QHYKFw+eWXp3Xr1nnooYdy6qmnZvjw4Rk1alSSZMaMGdlqq61y33335Yorrsizzz6bX//612nSpEnWW2+9nH322amrq8uYMWMyZsyY/M///E+j7c+YMSPbb799Pvjgg9x9990ZNWpU/vvf/2aXXXZp0O/ll1/OjTfemJtvvjk333xz7r777vz6179OkowZMya77bZbfvCDH+S5557LXXfdlR122CFFUcz/EwQAAABUhOlcAJhnbr755tTW1paeb7XVVmnduvUcrTtgwIAMGzYsSbLccsvlvPPOy+jRo7P55pvn9ttvz8MPP5znnnsuyy+/fJJkmWWWKa1bX1+fqqqqdOnSpez2R48enaeffjqvvPJKunfvniT5/e9/n5VWWimPPPJI1lxzzSSfh+2XXXZZ2rRpkyTZc889M3r06Jx44okZM2ZMPvvss+ywww7p0aNHkqR///5zenoAAACAbyEj0QGYZzbZZJM8+eSTpcc555wzx+sOGDCgwfOuXbvmnXfeSZI8+eSTWWqppUoB+tx47rnn0r1791KAniR9+/ZN27Zt89xzz5XaevbsWQrQv1zHyiuvnM022yz9+/fPTjvtlIsvvjgffvjhXNcEAAAALPyE6ADMM61bt86yyy5benTt2jXV1dWNpjuZNm1ao3WbNWvW4HlVVVVmzJiRJGnZsuX8K/pr1NGkSZOMGjUqt9xyS/r27Ztzzz03K6ywQl555ZUFVh8AAACwYAnRAZivOnbsmDFjxjRoe/LJJ7/WNgYMGJA333wz//nPf2a5vHnz5pk+ffpXbmPFFVfMG2+8kTfeeKPU9uyzz2b8+PHp27fvHNdSVVWV9ddfP8cdd1yeeOKJNG/ePDfccMMcrw8AAAB8uwjRAZivNt100zz66KP5/e9/nxdffDHDhg3LM88887W2MXDgwGy00UbZcccdM2rUqLzyyiu55ZZbcuuttyb5fAqWjz/+OKNHj857772XTz75pNE2Bg0alP79+2f33XfP448/nocffjh77bVXBg4cmDXWWGOO6njooYdy0kkn5dFHH83rr7+e66+/Pu+++25WXHHFr3U8AAAAwLeHEB2A+Wrw4ME5+uijc+SRR2bNNdfMRx99lL322utrb+fPf/5z1lxzzey2227p27dvjjzyyNLo8/XWWy8/+tGPsssuu6Rjx4459dRTG61fVVWVm266Ke3atctGG22UQYMGZZlllsm11147xzXU1dXlnnvuyXe+850sv/zy+dWvfpUzzjgjW2211dc+HgAAAODboar48kS1AAAAi7GJEyemvr4+EyZMSF1d3QLb78qPDV1g+wIWTk+tfmalS6iosdtuWOkSgArr8td/LtD9zel1n5HoAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAABY5IwYMSI9e/ZMixYtsvbaa+fhhx+udEkAAHxLCdEBAIBFyrXXXpuhQ4dm2LBhefzxx7Pyyitn8ODBeeeddypdGgAA30JCdAAAYJFy5pln5oc//GH23Xff9O3bNxdeeGFatWqVSy+9tNKlAQDwLSREBwAAFhlTp07NY489lkGDBpXaqqurM2jQoDzwwAMVrAwAgG+rppUuAAAAYF557733Mn369HTu3LlBe+fOnfP888/Pcp0pU6ZkypQppecTJkxIkkycOHH+FToL0z+eMvtOwCJtQb/vLGw+mvZZpUsAKqzVAn4fnPm+WxTFV/YTogMAAIu1k08+Occdd1yj9u7du1egGmBxVp/zK10CQGXV11dktx999FHqv2LfQnQAAGCRscQSS6RJkyYZN25cg/Zx48alS5cus1znqKOOytChQ0vPZ8yYkQ8++CAdOnRIVVXVfK0XZpo4cWK6d++eN954I3V1dZUuB2CB8z5IJRRFkY8++ijdunX7yn5CdAAAYJHRvHnzrL766hk9enSGDBmS5PNQfPTo0TnkkENmuU5NTU1qamoatLVt23Y+VwqzVldXJzwCFmveB1nQvmoE+kxCdAAAYJEydOjQ7L333lljjTWy1lpr5eyzz86kSZOy7777Vro0AAC+hYToAADAImWXXXbJu+++m2OOOSZjx47NKquskltvvbXRzUYBAGBOCNEBAIBFziGHHFJ2+hZYGNXU1GTYsGGNphYCWFx4H2RhVlUURVHpIgAAAAAAYGFUXekCAAAAAABgYSVEBwAAAACAMoToAAAAMA/07NkzZ5999lf2qaqqyo033pgkefXVV1NVVZUnn3xyvtcGMC/NyfsdLEqE6AAAACz29tlnn1RVVaWqqirNmzfPsssum+HDh+ezzz6bb/vs3r17xowZk379+n3jbQ0ePDhNmjTJI4880mjZ7I7trrvuSlVVVcaPH/+N6wC+Xeb2ve+RRx7JAQccMM/qmB9/VHzggQfSpEmTbL311mX3N/PRoUOHbLHFFnniiSdKfTbeeOMcdthh86wevt2E6AAAAJBkyy23zJgxY/Liiy/miCOOyLHHHpvTTjttvu2vSZMm6dKlS5o2bfqNtvP666/n/vvvzyGHHJJLL710ln0W9LEB3x5f5/1h6tSpSZKOHTumVatWC7LMr+2SSy7JoYcemnvuuSdvv/32LPvcfvvtGTNmTG677bZ8/PHH2WqrrfxBkVkSogMAAECSmpqadOnSJT169MhBBx2UQYMG5S9/+UuSWY9IHDJkSPbZZ58GbR999FF22223tG7dOksuuWRGjBhRdn+zGnn573//O9tss03q6urSpk2bbLjhhnn55Ze/su6RI0dmm222yUEHHZSrr746n3766dc6NmDx9lXvD/vss0+GDBmSE088Md26dcsKK6yQpOF0Lt///vezyy67NNjmtGnTssQSS+T3v/99kuTWW2/NBhtskLZt26ZDhw7ZZpttGry39erVK0my6qqrpqqqKhtvvHFp2e9+97usuOKKadGiRfr06ZPzzz9/tsf08ccf59prr81BBx2UrbfeOpdddtks+3Xo0CFdunTJGmuskdNPPz3jxo3LQw89NEfnjcWLEB0AAABmoWXLlqVRl3PqtNNOy8orr5wnnngiv/jFL/LTn/40o0aNmqN133rrrWy00UapqanJHXfckcceeyw/+MEPvnJahaIoMnLkyOyxxx7p06dPll122fzpT3+a7b7m5tiAxcOX3x9Gjx6dF154IaNGjcrNN9/cqP/uu++ev/71r/n4449Lbbfddls++eSTfPe7302STJo0KUOHDs2jjz6a0aNHp7q6Ot/97nczY8aMJMnDDz+c5P9Ghl9//fVJkiuvvDLHHHNMTjzxxDz33HM56aSTcvTRR+fyyy//ymP44x//mD59+mSFFVbIHnvskUsvvTRFUcz2uJN4b2SWvtl3xgAAAGARUxRFRo8endtuuy2HHnro11p3/fXXzy9+8YskyfLLL5/77rsvZ511VjbffPPZrjtixIjU19fnmmuuSbNmzUrb+Cq33357PvnkkwwePDhJsscee+SSSy7JnnvuOcv+3+TYgEVbufeH1q1b53e/+12aN28+y/UGDx6c1q1b54Ybbii991x11VXZbrvt0qZNmyTJjjvu2GCdSy+9NB07dsyzzz6bfv36pWPHjkn+b2T4TMOGDcsZZ5yRHXbYIcnnI9afffbZXHTRRdl7773LHssll1ySPfbYI8nn09VMmDAhd999d4MR7l80fvz4HH/88amtrc1aa631VaeJxZSR6AAAAJDk5ptvTm1tbVq0aJGtttoqu+yyS4499tivtY1111230fPnnntujtZ98skns+GGG5YC9Dlx6aWXZpdddinNq77bbrvlvvvuazQFzLw4NmDRNLv3h/79+5cN0JOkadOm2XnnnXPllVcm+XzU+U033ZTdd9+91OfFF1/MbrvtlmWWWSZ1dXXp2bNnks/v6VDOpEmT8vLLL2e//fZLbW1t6XHCCSd85TRXL7zwQh5++OHstttupfp22WWXXHLJJY36rrfeeqmtrU27du3y1FNP5dprr03nzp3LbpvFl5HoAAAAkGSTTTbJBRdckObNm6dbt24NbvhZXV3daCqAadOmzdP9z5xKYE598MEHueGGGzJt2rRccMEFpfbp06fn0ksvzYknnlhq+6pjAxZvs3t/aN269Wy3sfvuu2fgwIF55513MmrUqLRs2TJbbrllafm2226bHj165OKLL063bt0yY8aM9OvX7yunTpk5PczFF1+ctddeu8GyJk2alF3vkksuyWeffZZu3bqV2oqiSE1NTc4777zU19eX2q+99tr07ds3HTp0SNu2bWd7nCy+/NYEAACAfB4ULbvssrNc1rFjx4wZM6b0fPr06XnmmWeyySabNOj34IMPNnq+4oorztH+BwwYkMsvvzzTpk2bo9HoV155ZZZaaqnceOONDdr/8Y9/5Iwzzsjw4cNLQdNXHRuweJsX7w/rrbdeunfvnmuvvTa33HJLdtppp9L72Pvvv58XXnghF198cTbccMMkyb333ttg/Zkj3adPn15q69y5c7p165b//ve/DUa1f5XPPvssv//973PGGWdkiy22aLBsyJAhufrqq/OjH/2o1Na9e/f07t376x8wix0hOgAAAMzGpptumqFDh+Zvf/tbevfunTPPPDPjx49v1O++++7LqaeemiFDhmTUqFG57rrr8re//W2O9nHIIYfk3HPPza677pqjjjoq9fX1efDBB7PWWmtlhRVWaNT/kksuyfe+973069evQXv37t1z1FFH5dZbb83WW289V8cL8HV9//vfz4UXXpj//Oc/ufPOO0vt7dq1S4cOHfLb3/42Xbt2zeuvv166d8RMnTp1SsuWLXPrrbdmqaWWSosWLVJfX5/jjjsuP/nJT1JfX58tt9wyU6ZMyaOPPpoPP/wwQ4cObVTDzTffnA8//DD77bdfgxHnyefzsl9yySUNQnSYU+ZEBwAAgNn4wQ9+kL333jt77bVXBg4cmGWWWabRKPQkOeKII/Loo49m1VVXzQknnJAzzzyzdNPP2enQoUPuuOOOfPzxxxk4cGBWX331XHzxxbMclf7YY4/lqaeeanSzviSpr6/PZpttNsv5fwHml9133z3PPvtsllxyyay//vql9urq6lxzzTV57LHH0q9fvxx++OE57bTTGqzbtGnTnHPOObnooovSrVu3bL/99kmS/fffP7/73e8ycuTI9O/fPwMHDsxll12WXr16zbKGSy65JIMGDWoUoCefh+iPPvpo/vWvf83Do2ZxUVV8eVI3AAAAAAAgiZHoAAAAAABQlhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdYBGzzz77pGfPnpUuAwAAFlk9e/bMNttsU+kyFjsbb7xxNt544/m2/bvuuitVVVW566675ts+gG8nITowVy677LJUVVWVHi1atEi3bt0yePDgnHPOOfnoo48qXeJC7fzzz89ll1021+u//fbbOfbYY/Pkk0/Os5rmlYkTJ+a4447LyiuvnNra2rRs2TL9+vXLz3/+87z99tuVLg8AgEXMrD6bLL/88jnkkEMybty4Spe30HG9/vVcddVVOfvssytdBlBhVUVRFJUuAvj2ueyyy7Lvvvtm+PDh6dWrV6ZNm5axY8fmrrvuyqhRo7L00kvnL3/5SwYMGFDpUhdK/fr1yxJLLDHXIxweffTRrLnmmhk5cmT22WefBsumTZuWGTNmpKam5psX+jX997//zaBBg/L6669np512ygYbbJDmzZvnX//6V66++uq0b98+//nPfxZ4XQAALLq+/Nlk8uTJuffee/OHP/whPXr0yDPPPJNWrVrN03327Nkz/fr1y8033zxPtzu/fduv12eOQp9fI8VnzJiRqVOnpnnz5qmu/nzc6TbbbJNnnnkmr7766nzZJ/Dt0LTSBQDfbltttVXWWGON0vOjjjoqd9xxR7bZZptst912ee6559KyZcsKVrj4adasWUX2+9lnn2WHHXbIuHHjctddd2WDDTZosPzEE0/MKaecUpHaZmfSpElp3bp1pcsAAOAb+OJnk/333z8dOnTImWeemZtuuim77bZbhaurvG/z9fqCUl1dnRYtWlS6DGAhZDoXYJ7bdNNNc/TRR+e1117LFVdc0WDZHXfckQ033DCtW7dO27Zts/322+e5555rtI233nor++23X7p165aampr06tUrBx10UKZOnZokOfbYY1NVVdVovZlf5fziKIGZ8xXeddddWWONNdKyZcv079+/NHrh+uuvT//+/dOiRYusvvrqeeKJJxpt9/nnn8/3vve9tG/fPi1atMgaa6yRv/zlL7Pc93333ZehQ4emY8eOad26db773e/m3XffbVDPv//979x9992lr5zOHFHxwQcf5H/+53/Sv3//1NbWpq6uLltttVWeeuqp0vp33XVX1lxzzSTJvvvuW9rGzOlhZjUn+qRJk3LEEUeke/fuqampyQorrJDTTz89X/4yUlVVVQ455JDceOON6devX2pqarLSSivl1ltvbXROvuzPf/5znnrqqfzyl79sdEGeJHV1dTnxxBMbtF133XVZffXV07JlyyyxxBLZY4898tZbb5WWn3766amqqsprr73WaHtHHXVUmjdvng8//LDU9tBDD2XLLbdMfX19WrVqlYEDB+a+++5rsN7M186zzz6b73//+2nXrl2p3n/961/ZZ599sswyy6RFixbp0qVLfvCDH+T9999vtP+Zr6cWLVqkd+/eueiii8q+Lq+44orScbZv3z677rpr3njjjdmcUQAAvolNN900SfLKK68k+fzacr311kuHDh3SsmXLrL766vnTn/40y3WvuOKKrLXWWmnVqlXatWuXjTbaKP/4xz++cn+XX355mjZtmp/97GdJ5uzafqbXXnst2223XVq3bp1OnTrl8MMPz2233TbL+bnn5Jp3VubH9Xry+eeP2travP7669lmm21SW1ubJZdcMiNGjEiSPP3009l0003TunXr9OjRI1dddVWD9Wd+jrrnnnty4IEHpkOHDqmrq8tee+3V4Fq/nClTpmTYsGFZdtllU1NTk+7du+fII4/MlClTSn323nvvtGjRotFnz8GDB6ddu3alaWy+PCf6xhtvnL/97W957bXXSp+7evbsmY8//jitW7fOT3/600b1vPnmm2nSpElOPvnk2dYOfHsI0YH5Ys8990ySBheat99+ewYPHpx33nknxx57bIYOHZr7778/66+/foPQ++23385aa62Va665JrvsskvOOeec7Lnnnrn77rvzySefzFU9L730Ur7//e9n2223zcknn5wPP/ww2267ba688socfvjh2WOPPXLcccfl5Zdfzs4775wZM2aU1v33v/+dddZZJ88991x+8Ytf5Iwzzkjr1q0zZMiQ3HDDDY32deihh+app57KsGHDctBBB+Wvf/1rDjnkkNLys88+O0sttVT69OmTP/zhD/nDH/6QX/7yl0k+/3rljTfemG222SZnnnlmfvazn+Xpp5/OwIEDSxd2K664YoYPH54kOeCAA0rb2GijjWZ57EVRZLvttstZZ52VLbfcMmeeeWZWWGGF/OxnP8vQoUMb9b/33nvz4x//OLvuumtOPfXUTJ48OTvuuOMsg+QvmvlHhZk/+9m57LLLsvPOO5cuMH/4wx/m+uuvzwYbbJDx48cnSXbeeedUVVXlj3/8Y6P1//jHP2aLLbZIu3btknz+B5qNNtooEydOzLBhw3LSSSdl/Pjx2XTTTfPwww83Wn+nnXbKJ598kpNOOik//OEPkySjRo3Kf//73+y7774599xzs+uuu+aaa67Jd77znQZ/cHjiiSey5ZZb5v33389xxx2X/fbbL8OHD8+NN97YaD8nnnhi9tprryy33HI588wzc9hhh2X06NHZaKONSscJAMC89/LLLydJOnTokCT5zW9+k1VXXTXDhw/PSSedlKZNm2annXbK3/72twbrHXfccdlzzz3TrFmzDB8+PMcdd1y6d++eO+64o+y+fvvb32bffffNL37xi5x22mlJ5uzaPvl8wMumm26a22+/PT/5yU/yy1/+Mvfff39+/vOfN9rP173m/aL5cb0+0/Tp07PVVlule/fuOfXUU9OzZ88ccsghueyyy7LllltmjTXWyCmnnJI2bdpkr732Kv1h44sOOeSQPPfcczn22GOz11575corr8yQIUMaDfz5ohkzZmS77bbL6aefnm233TbnnntuhgwZkrPOOiu77LJLqd9vfvObdOzYMXvvvXemT5+eJLnooovyj3/8I+eee266des2y+3/8pe/zCqrrJIlllii9Lnr7LPPTm1tbb773e/m2muvLW1vpquvvjpFUWT33Xefo/MMfEsUAHNh5MiRRZLikUceKdunvr6+WHXVVUvPV1lllaJTp07F+++/X2p76qmniurq6mKvvfYqte21115FdXX1LLc9Y8aMoiiKYtiwYcWs3sJm1vXKK6+U2nr06FEkKe6///5S22233VYkKVq2bFm89tprpfaLLrqoSFLceeedpbbNNtus6N+/fzF58uQGday33nrFcsst12jfgwYNKtVZFEVx+OGHF02aNCnGjx9faltppZWKgQMHNqp/8uTJxfTp0xu0vfLKK0VNTU0xfPjwUtsjjzxSJClGjhzZaBt777130aNHj9LzG2+8sUhSnHDCCQ36fe973yuqqqqKl156qdSWpGjevHmDtqeeeqpIUpx77rmN9vVFq666alFfX/+VfWaaOnVq0alTp6Jfv37Fp59+Wmq/+eabiyTFMcccU2pbd911i9VXX73B+g8//HCRpPj9739fFMXnP4/llluuGDx4cINz/8knnxS9evUqNt9881LbzNfObrvt1qiuTz75pFHb1VdfXSQp7rnnnlLbtttuW7Rq1ap46623Sm0vvvhi0bRp0wavy1dffbVo0qRJceKJJzbY5tNPP100bdq0UTsAAF/fzOvw22+/vXj33XeLN954o7jmmmuKDh06FC1btizefPPNoigaX+tNnTq16NevX7HpppuW2l588cWiurq6+O53v9vouvyL15k9evQott5666IoiuI3v/lNUVVVVRx//PEN+s/ptf0ZZ5xRJCluvPHGUtunn35a9OnTp8Fnk69zzTsr8+t6fe+99y6SFCeddFKp7cMPPyxatmxZVFVVFddcc02p/fnnny+SFMOGDSu1zfz5rb766sXUqVNL7aeeemqRpLjppptKbQMHDmzwOeoPf/hDUV1dXfzzn/9sUP+FF15YJCnuu+++UtvMz4AnnHBC8d///reora0thgwZ0mC9O++8s9Hnwa233rrB56svb++WW25p0D5gwIBZftYDvt2MRAfmm9ra2nz00UdJkjFjxuTJJ5/MPvvsk/bt25f6DBgwIJtvvnn+/ve/J/l8JMGNN96YbbfdtsFc6zPNaqqMOdG3b9+su+66pedrr712ks+/4rn00ks3av/vf/+b5POvYN5xxx3Zeeed89FHH+W9997Le++9l/fffz+DBw/Oiy++2OjrjAcccECDOjfccMNMnz59llOSfFlNTU3pBjbTp0/P+++/n9ra2qywwgp5/PHH5+rY//73v6dJkyb5yU9+0qD9iCOOSFEUueWWWxq0Dxo0KL179y49HzBgQOrq6krnpJyJEyemTZs2c1TTo48+mnfeeSc//vGPG8w5uPXWW6dPnz4NRgPtsssueeyxx0ojiZLk2muvTU1NTbbffvskyZNPPpkXX3wx3//+9/P++++Xfk6TJk3KZpttlnvuuafBtwuS5Ec/+lGjur44f//kyZPz3nvvZZ111kmS0vmfPn16br/99gwZMqTBiJVll102W221VYPtXX/99ZkxY0Z23nnnUk3vvfdeunTpkuWWWy533nnnHJ0vAABmb9CgQenYsWO6d++eXXfdNbW1tbnhhhuy5JJLJml4rffhhx9mwoQJ2XDDDRtcZ994442ZMWNGjjnmmNJ1+Uyz+ixy6qmn5qc//WlOOeWU/OpXv2qwbE6v7W+99dYsueSS2W677UptLVq0KH1bcqa5ueb9ovl1vT7T/vvvX/p327Zts8IKK6R169bZeeedS+0rrLBC2rZtO8vPFgcccECD+zsddNBBadq0aemz4qxcd911WXHFFdOnT58G19szp/L54vX2FltskQMPPDDDhw/PDjvskBYtWuSiiy6ao/MxK4MGDUq3bt1y5ZVXltqeeeaZ/Otf/8oee+wx19sFFk5uLArMNx9//HE6deqUJKUAeYUVVmjUb8UVV8xtt92WSZMm5eOPP87EiRPTr1+/eVrLF4PyJKmvr0+SdO/efZbtM+fee+mll1IURY4++ugcffTRs9z2O++8U7own9W+Zk43Mifz+c2YMSO/+c1vcv755+eVV15p8NXAmV9D/bpee+21dOvWrdEF84orrlha/kVfrj/5/BhmV/+cBO1frCmZ9euhT58+uffee0vPd9pppwwdOjTXXntt/vd//zdFUeS6667LVlttlbq6uiTJiy++mOTzuQ7LmTBhQulnkSS9evVq1OeDDz7Icccdl2uuuSbvvPNOo/WTz3/en376aZZddtlG63+57cUXX0xRFFluueVmWVOlbgILALAoGjFiRJZffvk0bdo0nTt3zgorrNAgCL/55ptzwgkn5Mknn2wwX/YXw/GXX3451dXV6du372z3d/fdd+dvf/tbfv7zn5fmQf+iOb22f+2119K7d+9GIf2sri2Tr3fN+0Xz63o9+Tz079ixY4O2+vr6LLXUUo2Oq76+fpafLb58zVxbW5uuXbs2mPrzy1588cU899xzjfY905ev6U8//fTcdNNNefLJJ3PVVVeVPq/Ojerq6uy+++654IIL8sknn6RVq1a58sor06JFi+y0005zvV1g4SREB+aLN998MxMmTJhl0DgvlBuR/uX56GZq0qTJ12ov/v+8ezNHcvzP//xPBg8ePMu+Xz7G2W3zq5x00kk5+uij84Mf/CDHH3982rdvn+rq6hx22GFfOapkXprb+vv06ZMnnngib7zxRqM/TnwT3bp1y4Ybbpg//vGP+d///d88+OCDef3113PKKaeU+sw8N6eddlpWWWWVWW6ntra2wfMvjkSaaeedd87999+fn/3sZ1lllVVSW1ubGTNmZMstt5yr8z9jxoxUVVXllltumeV5/XJNAADMvbXWWmuW32ZNkn/+85/ZbrvtstFGG+X8889P165d06xZs4wcObLRjS7n1EorrZTx48fnD3/4Qw488MBGgzTm9bX93FzzftH8ul5P5v7z1jc1Y8aM9O/fP2eeeeYsl3/5OJ944olSsP70009nt912+0b732uvvXLaaaflxhtvzG677Zarrroq22yzTWlwFrDoEKID88Uf/vCHJCkFzz169EiSvPDCC436Pv/881liiSXSunXrtGzZMnV1dXnmmWe+cvszR1eMHz8+bdu2LbXPyZQpX8cyyyyT5PMRw4MGDZpn2y33R4A//elP2WSTTXLJJZc0aB8/fnyWWGKJ2a4/Kz169Mjtt9+ejz76qMFo9Oeff760fF7Ydtttc/XVV+eKK67IUUcdNduaks9fDzO/ajnTCy+80KimXXbZJT/+8Y/zwgsv5Nprr02rVq2y7bbblpbPnH6mrq5urn9OH374YUaPHp3jjjsuxxxzTKl95oifmTp16pQWLVrkpZdearSNL7f17t07RVGkV69eWX755eeqLgAAvrk///nPadGiRW677bbU1NSU2keOHNmgX+/evTNjxow8++yzZYPqmZZYYon86U9/ygYbbJDNNtss9957b4Pp/ub02r5Hjx559tlnUxRFg+v8WV1bJnN/zTs/r9fnhRdffDGbbLJJ6fnHH3+cMWPG5Dvf+U7ZdXr37p2nnnoqm2222Ww/I02aNCn77rtv+vbtm/XWWy+nnnpqvvvd72bNNdf8yvW+arv9+vXLqquumiuvvDJLLbVUXn/99Zx77rlfuT3g28mc6MA8d8cdd+T4449Pr169Snck79q1a1ZZZZVcfvnlDe7k/swzz+Qf//hH6cKouro6Q4YMyV//+tc8+uijjbY9c8TCzAvIe+65p7Rs0qRJufzyy+fpsXTq1Ckbb7xxLrrooowZM6bR8nfffXeuttu6detGd7RPPh+p8eVRGdddd12jeddbt26dJLPcxpd95zvfyfTp03Peeec1aD/rrLNSVVXVaB7vufW9730v/fv3z4knnpgHHnig0fKPPvoov/zlL5Mka6yxRjp16pQLL7ywwVdpb7nlljz33HPZeuutG6y74447pkmTJrn66qtz3XXXZZtttimdgyRZffXV07t375x++un5+OOPG+17Tn5OM0fJfPn8n3322Y36DRo0KDfeeGPefvvtUvtLL73UaH75HXbYIU2aNMlxxx3XaLtFUeT999+fbV0AAHxzTZo0SVVVVYNvrr766qu58cYbG/QbMmRIqqurM3z48EajxWc1enqppZbK7bffnk8//TSbb755g+u7Ob22Hzx4cN5666385S9/KbVNnjw5F198cYN+3/Sad35er88Lv/3tbzNt2rTS8wsuuCCfffbZV35e2XnnnfPWW281OldJ8umnn2bSpEml5z//+c/z+uuv5/LLL8+ZZ56Znj17Zu+9925wfLPSunXr0tSOs7LnnnvmH//4R84+++x06NBhnn2+AhYuRqID38gtt9yS559/Pp999lnGjRuXO+64I6NGjUqPHj3yl7/8pcFNaE477bRstdVWWXfddbPffvvl008/zbnnnpv6+voce+yxpX4nnXRS/vGPf2TgwIE54IADsuKKK2bMmDG57rrrcu+996Zt27bZYostsvTSS2e//fbLz372szRp0iSXXnppOnbsmNdff32eHuOIESOywQYbpH///vnhD3+YZZZZJuPGjcsDDzyQN998M0899dTX3ubqq6+eCy64ICeccEKWXXbZdOrUKZtuumm22WabDB8+PPvuu2/WW2+9PP3007nyyitLI+Jn6t27d9q2bZsLL7wwbdq0SevWrbP22mvPcp7vbbfdNptsskl++ctf5tVXX83KK6+cf/zjH7npppty2GGHNbiJ6DfRrFmzXH/99Rk0aFA22mij7Lzzzll//fXTrFmz/Pvf/85VV12Vdu3a5cQTT0yzZs1yyimnZN99983AgQOz2267Zdy4cfnNb36Tnj175vDDD2+w7U6dOmWTTTbJmWeemY8++ii77LJLg+XV1dX53e9+l6222iorrbRS9t133yy55JJ56623cuedd6auri5//etfv7L+urq6bLTRRjn11FMzbdq0LLnkkvnHP/6RV155pVHfY489Nv/4xz+y/vrr56CDDir9kaJfv3558sknS/169+6dE044IUcddVReffXVDBkyJG3atMkrr7ySG264IQcccED+53/+Z+5POgAAc2TrrbfOmWeemS233DLf//73884772TEiBFZdtll869//avUb9lll80vf/nLHH/88dlwww2zww47pKamJo888ki6deuWk08+udG2l1122fzjH//IxhtvnMGDB+eOO+5IXV3dHF/bH3jggTnvvPOy22675ac//Wm6du1amls7+b+R0N/0mnd+Xq/PC1OnTs1mm22WnXfeOS+88ELOP//8bLDBBg1uuPple+65Z/74xz/mRz/6Ue68886sv/76mT59ep5//vn88Y9/zG233ZY11lgjd9xxR84///wMGzYsq622WpLPv4Ww8cYb5+ijj86pp55adh+rr756rr322gwdOjRrrrlmamtrG3wr9vvf/36OPPLI3HDDDTnooIPc9wgWVQXAXBg5cmSRpPRo3rx50aVLl2LzzTcvfvOb3xQTJ06c5Xq33357sf766xctW7Ys6urqim233bZ49tlnG/V77bXXir322qvo2LFjUVNTUyyzzDLFwQcfXEyZMqXU57HHHivWXnvtonnz5sXSSy9dnHnmmaW6XnnllVK/Hj16FFtvvXWjfSQpDj744AZtr7zySpGkOO200xq0v/zyy8Vee+1VdOnSpWjWrFmx5JJLFttss03xpz/9qdE5eeSRRxqse+eddxZJijvvvLPUNnbs2GLrrbcu2rRpUyQpBg4cWBRFUUyePLk44ogjiq5duxYtW7Ys1l9//eKBBx4oBg4cWOoz00033VT07du3aNq0aZGkGDlyZFEURbH33nsXPXr0aND3o48+Kg4//PCiW7duRbNmzYrllluuOO2004oZM2bM9pzMPId77713o/ZZ+fDDD4tjjjmm6N+/f9GqVauiRYsWRb9+/YqjjjqqGDNmTIO+1157bbHqqqsWNTU1Rfv27Yvdd9+9ePPNN2e53YsvvrhIUrRp06b49NNPZ9nniSeeKHbYYYeiQ4cORU1NTdGjR49i5513LkaPHl3qM2zYsCJJ8e677zZa/8033yy++93vFm3bti3q6+uLnXbaqXj77beLJMWwYcMa9B09enSx6qqrFs2bNy969+5d/O53vyuOOOKIokWLFo22++c//7nYYIMNitatWxetW7cu+vTpUxx88MHFCy+8MLvTCQDAbJS7Dv+ySy65pFhuueWKmpqaok+fPsXIkSNL14Zfdumll5auU9u1a1cMHDiwGDVqVGn5rD5jPPTQQ0WbNm2KjTbaqPjkk0++1rX9f//732LrrbcuWrZsWXTs2LE44ogjij//+c9FkuLBBx9s0HdOrnm/yry+Xt97772L1q1bN9rPwIEDi5VWWqlR+5fP3cyf3913310ccMABRbt27Yra2tpi9913L95///1G2/zyuZs6dWpxyimnFCuttFLp57X66qsXxx13XDFhwoRi4sSJRY8ePYrVVlutmDZtWoN1Dz/88KK6urp44IEHiqKY9We3jz/+uPj+979ftG3btkjS6LNWURTFd77znSJJcf/99zdaBiwaqopiHt3NAQAWc0OGDMm///3vRvOoAwDA13X22Wfn8MMPz5tvvpkll1yy0uXMN5dddln23XffPPLII2VvDLuw++53v5unn356lvdNAhYN5kQHgLnw6aefNnj+4osv5u9//3s23njjyhQEAMC31pevLSdPnpyLLrooyy233CIdoC8KxowZk7/97W/Zc889K10KMB+ZEx0A5sIyyyyTffbZJ8sss0xee+21XHDBBWnevHmOPPLISpcGAMC3zA477JCll146q6yySiZMmJArrrgizz//fK688spKl0YZr7zySu6777787ne/S7NmzXLggQdWuiRgPhKiA8Bc2HLLLXP11Vdn7NixqampybrrrpuTTjopyy23XKVLAwDgW2bw4MH53e9+lyuvvDLTp09P3759c80112SXXXapdGmUcffdd2fffffN0ksvncsvvzxdunSpdEnAfGROdAAAAAAAKMOc6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGYv8jUVnzJiRt99+O23atElVVVWlywEAYD4piiIfffRRunXrlupqY0WYez5DAAAsHub0M8QiH6K//fbb6d69e6XLAABgAXnjjTey1FJLVboMvsV8hgAAWLzM7jPEIh+it2nTJsnnJ6Kurq7C1QAAML9MnDgx3bt3L13/wdzyGQIAYPEwp58hFvkQfebXL+vq6lwAAwAsBky/wTflMwQAwOJldp8hTBYJAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGU0rXQAAAMDC6PL9RqVls1aVLgMAYLGw/1VbVbqEsoToAMwXH1/SodIlABVWu9/7lS4BAADgGzOdCwAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKqGiIPn369Bx99NHp1atXWrZsmd69e+f4449PURSlPkVR5JhjjknXrl3TsmXLDBo0KC+++GIFqwYAAAAAYHFR0RD9lFNOyQUXXJDzzjsvzz33XE455ZSceuqpOffcc0t9Tj311Jxzzjm58MIL89BDD6V169YZPHhwJk+eXMHKAQAAAABYHDSt5M7vv//+bL/99tl6662TJD179szVV1+dhx9+OMnno9DPPvvs/OpXv8r222+fJPn973+fzp0758Ybb8yuu+5asdoBAAAAAFj0VXQk+nrrrZfRo0fnP//5T5Lkqaeeyr333putttoqSfLKK69k7NixGTRoUGmd+vr6rL322nnggQdmuc0pU6Zk4sSJDR4AAAAAADA3KjoS/Re/+EUmTpyYPn36pEmTJpk+fXpOPPHE7L777kmSsWPHJkk6d+7cYL3OnTuXln3ZySefnOOOO27+Fg4AAAAAwGKhoiPR//jHP+bKK6/MVVddlccffzyXX355Tj/99Fx++eVzvc2jjjoqEyZMKD3eeOONeVgxAAAAAACLk4qORP/Zz36WX/ziF6W5zfv375/XXnstJ598cvbee+906dIlSTJu3Lh07dq1tN64ceOyyiqrzHKbNTU1qampme+1AwAAAACw6KvoSPRPPvkk1dUNS2jSpElmzJiRJOnVq1e6dOmS0aNHl5ZPnDgxDz30UNZdd90FWisAAAAAAIufio5E33bbbXPiiSdm6aWXzkorrZQnnngiZ555Zn7wgx8kSaqqqnLYYYflhBNOyHLLLZdevXrl6KOPTrdu3TJkyJBKlg4AAAAAwGKgoiH6ueeem6OPPjo//vGP884776Rbt2458MADc8wxx5T6HHnkkZk0aVIOOOCAjB8/PhtssEFuvfXWtGjRooKVAwAAAACwOKgqiqKodBHz08SJE1NfX58JEyakrq6u0uUALDY+vqRDpUsAKqx2v/cX6P5c9zGvzHwtnfO9P6Vls1aVLgcAYLGw/1VbLfB9zulniIrOiQ4AAAAAAAszIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJTRtNIFLKrWvOilSpcAVNgjBy5b6RIAAAAA+IaMRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGRUP0d96663sscce6dChQ1q2bJn+/fvn0UcfLS0viiLHHHNMunbtmpYtW2bQoEF58cUXK1gxAAAAAACLi4qG6B9++GHWX3/9NGvWLLfcckueffbZnHHGGWnXrl2pz6mnnppzzjknF154YR566KG0bt06gwcPzuTJkytYOQAAAAAAi4Omldz5Kaecku7du2fkyJGltl69epX+XRRFzj777PzqV7/K9ttvnyT5/e9/n86dO+fGG2/MrrvuusBrBgAAAABg8VHRkeh/+ctfssYaa2SnnXZKp06dsuqqq+biiy8uLX/llVcyduzYDBo0qNRWX1+ftddeOw888MAstzllypRMnDixwQMAAAAAAOZGRUP0//73v7nggguy3HLL5bbbbstBBx2Un/zkJ7n88suTJGPHjk2SdO7cucF6nTt3Li37spNPPjn19fWlR/fu3efvQQAAAAAAsMiqaIg+Y8aMrLbaajnppJOy6qqr5oADDsgPf/jDXHjhhXO9zaOOOioTJkwoPd544415WDEAAAAAAIuTioboXbt2Td++fRu0rbjiinn99deTJF26dEmSjBs3rkGfcePGlZZ9WU1NTerq6ho8AAAAAABgblQ0RF9//fXzwgsvNGj7z3/+kx49eiT5/CajXbp0yejRo0vLJ06cmIceeijrrrvuAq0VAAAAAIDFT9NK7vzwww/Peuutl5NOOik777xzHn744fz2t7/Nb3/72yRJVVVVDjvssJxwwglZbrnl0qtXrxx99NHp1q1bhgwZUsnSAQAAAABYDFQ0RF9zzTVzww035Kijjsrw4cPTq1evnH322dl9991LfY488shMmjQpBxxwQMaPH58NNtggt956a1q0aFHBygEAAAAAWBxUNERPkm222SbbbLNN2eVVVVUZPnx4hg8fvgCrAgAAAACACs+JDgAAAAAACzMhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlDFXIfoyyyyT999/v1H7+PHjs8wyy3zjogAAAAAAYGEwVyH6q6++munTpzdqnzJlSt56661vXBQAAAAAACwMmn6dzn/5y19K/77ttttSX19fej59+vSMHj06PXv2nGfFAQAAAABAJX2tEH3IkCFJkqqqquy9994NljVr1iw9e/bMGWecMc+KAwAAAACASvpaIfqMGTOSJL169cojjzySJZZYYr4UBQAAAAAAC4OvFaLP9Morr8zrOgAAAAAAYKEzVyF6kowePTqjR4/OO++8UxqhPtOll176jQsDAAAAAIBKm6sQ/bjjjsvw4cOzxhprpGvXrqmqqprXdQEAAAAAQMXNVYh+4YUX5rLLLsuee+45r+sBAAAAAICFRvXcrDR16tSst95687oWAAAAAABYqMxViL7//vvnqquumte1AAAAAADAQmWupnOZPHlyfvvb3+b222/PgAED0qxZswbLzzzzzHlSHAAAAAAAVNJchej/+te/ssoqqyRJnnnmmQbL3GQUAAAAAIBFxVyF6Hfeeee8rgMAAJiNV199Nb169coTTzxRGtTyTW288cZZZZVVcvbZZ8+T7QEAwKJmruZEBwCARdXYsWNz6KGHZplllklNTU26d++ebbfdNqNHj650afPF9ddfn+OPP770vGfPnvMkUH/33Xdz0EEHZemll05NTU26dOmSwYMH57777vvG2wYAgAVprkaib7LJJl85bcsdd9wx1wUBAEClvPrqq1l//fXTtm3bnHbaaenfv3+mTZuW2267LQcffHCef/75Spc4z7Vv336+bHfHHXfM1KlTc/nll2eZZZbJuHHjMnr06Lz//vvzZX9JMnXq1DRv3ny+bR8AgMXTXI1EX2WVVbLyyiuXHn379s3UqVPz+OOPp3///vO6RgAAWCB+/OMfp6qqKg8//HB23HHHLL/88llppZUydOjQPPjgg6V+r7/+erbffvvU1tamrq4uO++8c8aNG1dafuyxx2aVVVbJpZdemqWXXjq1tbX58Y9/nOnTp+fUU09Nly5d0qlTp5x44okN9l9VVZULLrggW221VVq2bJllllkmf/rTn76y5meeeSZbbbVVamtr07lz5+y555557733kiR33XVXmjdvnn/+85+l/qeeemo6depUqnfjjTfOYYcdVvr3a6+9lsMPPzxVVVWpqqrKpEmTUldX16iOG2+8Ma1bt85HH33UqKbx48fnn//8Z0455ZRssskm6dGjR9Zaa60cddRR2W677Rr0O/DAA9O5c+e0aNEi/fr1y80331xa/uc//zkrrbRSampq0rNnz5xxxhkN9tOzZ88cf/zx2WuvvVJXV5cDDjggSXLvvfdmww03TMuWLdO9e/f85Cc/yaRJk77yPAIAQDlzFaKfddZZDR7nnXde7r333hx22GFp1qzZvK4RAADmuw8++CC33nprDj744LRu3brR8rZt2yZJZsyYke233z4ffPBB7r777owaNSr//e9/s8suuzTo//LLL+eWW27JrbfemquvvjqXXHJJtt5667z55pu5++67c8opp+RXv/pVHnrooQbrHX300dlxxx3z1FNPZffdd8+uu+6a5557bpY1jx8/PptuumlWXXXVPProo7n11lszbty47Lzzzkn+LyDfc889M2HChDzxxBM5+uij87vf/S6dO3dutL3rr78+Sy21VIYPH54xY8ZkzJgxad26dXbdddeMHDmyQd+RI0fme9/7Xtq0adNoO7W1tamtrc2NN96YKVOmzLL2GTNmZKuttsp9992XK664Is8++2x+/etfp0mTJkmSxx57LDvvvHN23XXXPP300zn22GNz9NFH57LLLmuwndNPPz0rr7xy6dhefvnlbLnlltlxxx3zr3/9K9dee23uvffeHHLIIbOsAwAAZmeupnMpZ4899shaa62V008/fV5uFgAA5ruXXnopRVGkT58+X9lv9OjRefrpp/PKK6+ke/fuSZLf//73WWmllfLII49kzTXXTPJ5SHzppZemTZs26du3bzbZZJO88MIL+fvf/57q6uqssMIKOeWUU3LnnXdm7bXXLm1/p512yv77758kOf744zNq1Kice+65Of/88xvVct5552XVVVfNSSedVGq79NJL07179/znP//J8ssvnxNOOCGjRo3KAQcckGeeeSZ77713g9HgX9S+ffs0adIkbdq0SZcuXUrt+++/f9Zbb72MGTMmXbt2zTvvvJO///3vuf3222e5naZNm+ayyy7LD3/4w1x44YVZbbXVMnDgwOy6664ZMGBAkuT222/Pww8/nOeeey7LL798kmSZZZYpbePMM8/MZpttlqOPPjpJsvzyy+fZZ5/Naaedln322afUb9NNN80RRxzRoNbdd9+9NLp+ueWWyznnnJOBAwfmggsuSIsWLRrVO2XKlAZh/8SJE2d5XAAALJ7m6Y1FH3jggVlelAIAwMKuKIo56vfcc8+le/fupQA9Sfr27Zu2bds2GDHes2fPBqO0O3funL59+6a6urpB2zvvvNNg++uuu26j5+VGoj/11FO58847SyO/a2trS38EePnll5MkzZs3z5VXXpk///nPmTx5cs4666w5Os4vWmuttbLSSivl8ssvT5JcccUV6dGjRzbaaKOy6+y44455++2385e//CVbbrll7rrrrqy22mqlkeRPPvlkllpqqVKA/mXPPfdc1l9//QZt66+/fl588cVMnz691LbGGms06PPUU0/lsssua3BOBg8enBkzZuSVV16Z5b5OPvnk1NfXlx5f/NkCAMBcjUTfYYcdGjwviiJjxozJo48+WhopAgAA3ybLLbdcqqqq5tnNQ788zWFVVdUs22bMmDHX+/j444+z7bbb5pRTTmm0rGvXrqV/33///Uk+n7Lmgw8+mOV0NbOz//77Z8SIEfnFL36RkSNHZt99901VVdVXrtOiRYtsvvnm2XzzzXP00Udn//33z7Bhw7LPPvukZcuWX7uGWfnysXz88cc58MAD85Of/KRR36WXXnqW2zjqqKMydOjQ0vOJEycK0gEAKJmrkehfHKVRX1+f9u3bZ+ONN87f//73DBs2bF7XCAAA81379u0zePDgjBgxYpY3oRw/fnySZMUVV8wbb7yRN954o7Ts2Wefzfjx49O3b99vXMcXb2A68/mKK644y76rrbZa/v3vf6dnz55ZdtllGzxmhssvv/xyDj/88Fx88cVZe+21s/fee39lcN+8efMGI71n2mOPPfLaa6/lnHPOybPPPpu99977ax9b3759S+d2wIABefPNN/Of//xnln1XXHHF3HfffQ3a7rvvviy//PKledNnZbXVVsuzzz7b6Hwsu+yyad68+SzXqampSV1dXYMHAADMNFcj0b98UyEAAFgUjBgxIuuvv37WWmutDB8+PAMGDMhnn32WUaNG5YILLshzzz2XQYMGpX///tl9991z9tln57PPPsuPf/zjDBw4sNHUInPjuuuuyxprrJENNtggV155ZR5++OFccskls+x78MEH5+KLL85uu+2WI488Mu3bt89LL72Ua665Jr/73e+SfB5+Dx48OPvuu2+23HLL9O/fP2eccUZ+9rOfzXKbPXv2zD333JNdd901NTU1WWKJJZIk7dq1yw477JCf/exn2WKLLbLUUkuVPYb3338/O+20U37wgx9kwIABadOmTR599NGceuqp2X777ZMkAwcOzEYbbZQdd9wxZ555ZpZddtk8//zzqaqqypZbbpkjjjgia665Zo4//vjssssueeCBB3LeeefNcm74L/r5z3+eddZZJ4ccckj233//tG7dOs8++2xGjRqV8847b7bnHwAAvuwbzYn+2GOP5YorrsgVV1yRJ554Yl7VBAAAFbHMMsvk8ccfzyabbJIjjjgi/fr1y+abb57Ro0fnggsuSPL5FCw33XRT2rVrl4022iiDBg3KMsssk2uvvXae1HDcccflmmuuyYABA/L73/8+V199ddkR7t26dct9992X6dOnZ4sttkj//v1z2GGHpW3btqmurs6JJ56Y1157LRdddFGSz6d4+e1vf5tf/epXeeqpp2a5zeHDh+fVV19N796907FjxwbL9ttvv0ydOjU/+MEPvvIYamtrs/baa+ess87KRhttlH79+uXoo4/OD3/4wwZB9p///Oesueaa2W233dK3b98ceeSRpVHwq622Wv74xz/mmmuuSb9+/XLMMcdk+PDhDW4qOisDBgzI3Xffnf/85z/ZcMMNs+qqq+aYY45Jt27dvnI9AAAop6qY0zsofcE777yTXXfdNXfddVfatm2b5POvt26yySa55pprGl1sV9LEiRNTX1+fCRMmLNCvZa550UsLbF/AwumRA5etdAkV9fElHSpdAlBhtfu9v0D3V6nrvnmpqqoqN9xwQ4YMGVLpUmbpD3/4Qw4//PC8/fbbZadGWRTMfC2d870/pWWzVpUuBwBgsbD/VVst8H3O6WeIuRqJfuihh+ajjz7Kv//979LNiZ555plMnDhxljfwAQAAvr0++eSTvPzyy/n1r3+dAw88cJEO0AEA4MvmKkS/9dZbc/755ze4wVHfvn0zYsSI3HLLLfOsOAAAoPJOPfXU9OnTJ126dMlRRx1V6XIAAGCBmqsbi86YMSPNmjVr1N6sWbPMmDHjGxcFAACLo7mYaXGBOPbYY3PsscdWugwAAKiIuRqJvummm+anP/1p3n777VLbW2+9lcMPPzybbbbZPCsOAAAAAAAqaa5C9PPOOy8TJ05Mz54907t37/Tu3Tu9evXKxIkTc+65587rGgEAAAAAoCLmajqX7t275/HHH8/tt9+e559/Pkmy4oorZtCgQfO0OAAAAAAAqKSvNRL9jjvuSN++fTNx4sRUVVVl8803z6GHHppDDz00a665ZlZaaaX885//nF+1AgAAAADAAvW1QvSzzz47P/zhD1NXV9doWX19fQ488MCceeaZ86w4AAAAAACopK8Voj/11FPZcsstyy7fYost8thjj33jogAAAAAAYGHwtUL0cePGpVmzZmWXN23aNO++++43LgoAAAAAABYGXytEX3LJJfPMM8+UXf6vf/0rXbt2/cZFAQAAAADAwuBrhejf+c53cvTRR2fy5MmNln366acZNmxYttlmm3lWHAAAAAAAVFLTr9P5V7/6Va6//vosv/zyOeSQQ7LCCiskSZ5//vmMGDEi06dPzy9/+cv5UigAAAAAACxoXytE79y5c+6///4cdNBBOeqoo1IURZKkqqoqgwcPzogRI9K5c+f5UigAAAAAACxoXytET5IePXrk73//ez788MO89NJLKYoiyy23XNq1azc/6gMAAAAAgIr52iH6TO3atcuaa645L2sBAAAAAICFyte6sSgAAAAAACxOhOgAAAAAAFCGEB0AAAAAAMoQogMAAAAAQBlCdAAAAAAAKEOIDgAAAAAAZQjRAQAAAACgDCE6AAAAAACUIUQHAAAAAIAyhOgAAAAAAFCGEB0AAAAAAMpYaEL0X//616mqqsphhx1Waps8eXIOPvjgdOjQIbW1tdlxxx0zbty4yhUJAAAAAMBiZaEI0R955JFcdNFFGTBgQIP2ww8/PH/9619z3XXX5e67787bb7+dHXbYoUJVAgAAAACwuKl4iP7xxx9n9913z8UXX5x27dqV2idMmJBLLrkkZ555ZjbddNOsvvrqGTlyZO6///48+OCDFawYAAAAAIDFRcVD9IMPPjhbb711Bg0a1KD9sccey7Rp0xq09+nTJ0svvXQeeOCBBV0mAAAAAACLoaaV3Pk111yTxx9/PI888kijZWPHjk3z5s3Ttm3bBu2dO3fO2LFjy25zypQpmTJlSun5xIkT51m9AAAAAAAsXio2Ev2NN97IT3/601x55ZVp0aLFPNvuySefnPr6+tKje/fu82zbAAAAAAAsXioWoj/22GN55513stpqq6Vp06Zp2rRp7r777pxzzjlp2rRpOnfunKlTp2b8+PEN1hs3bly6dOlSdrtHHXVUJkyYUHq88cYb8/lIAAAAAABYVFVsOpfNNtssTz/9dIO2fffdN3369MnPf/7zdO/ePc2aNcvo0aOz4447JkleeOGFvP7661l33XXLbrempiY1NTXztXYAAAAAABYPFQvR27Rpk379+jVoa926dTp06FBq32+//TJ06NC0b98+dXV1OfTQQ7PuuutmnXXWqUTJAAAAAAAsZip6Y9HZOeuss1JdXZ0dd9wxU6ZMyeDBg3P++edXuiwAAAAAABYTC1WIftdddzV43qJFi4wYMSIjRoyoTEEAAAAAACzWKnZjUQAAAAAAWNgJ0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZQnQAAAAAAChDiA4AAAAAAGUI0QEAAAAAoAwhOgAAAAAAlCFEBwAAAACAMoToAAAAAABQhhAdAAAAAADKEKIDAAAAAEAZFQ3RTz755Ky55ppp06ZNOnXqlCFDhuSFF15o0Gfy5Mk5+OCD06FDh9TW1mbHHXfMuHHjKlQxAAAAAACLk4qG6HfffXcOPvjgPPjggxk1alSmTZuWLbbYIpMmTSr1Ofzww/PXv/411113Xe6+++68/fbb2WGHHSpYNQAAAAAAi4umldz5rbfe2uD5ZZddlk6dOuWxxx7LRhttlAkTJuSSSy7JVVddlU033TRJMnLkyKy44op58MEHs84661SibAAAAAAAFhML1ZzoEyZMSJK0b98+SfLYY49l2rRpGTRoUKlPnz59svTSS+eBBx6oSI0AAAAAACw+KjoS/YtmzJiRww47LOuvv3769euXJBk7dmyaN2+etm3bNujbuXPnjB07dpbbmTJlSqZMmVJ6PnHixPlWMwAAAAAAi7aFZiT6wQcfnGeeeSbXXHPNN9rOySefnPr6+tKje/fu86hCAAAAAAAWNwtFiH7IIYfk5ptvzp133pmlllqq1N6lS5dMnTo148ePb9B/3Lhx6dKlyyy3ddRRR2XChAmlxxtvvDE/SwcAAAAAYBFW0RC9KIoccsghueGGG3LHHXekV69eDZavvvrqadasWUaPHl1qe+GFF/L6669n3XXXneU2a2pqUldX1+ABAAAAAABzo6Jzoh988MG56qqrctNNN6VNmzalec7r6+vTsmXL1NfXZ7/99svQoUPTvn371NXV5dBDD826666bddZZp5KlAwAAAACwGKhoiH7BBRckSTbeeOMG7SNHjsw+++yTJDnrrLNSXV2dHXfcMVOmTMngwYNz/vnnL+BKAQAAAABYHFU0RC+KYrZ9WrRokREjRmTEiBELoCIAAAAAAPg/C8WNRQEAAAAAYGEkRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJTRtNIFAAAALIz2vmTz1NXVVboMAAAqzEh0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDKE6AAAAAAAUIYQHQAAAAAAyhCiAwAAAABAGUJ0AAAAAAAoQ4gOAAAAAABlCNEBAAAAAKAMIToAAAAAAJQhRAcAAAAAgDK+FSH6iBEj0rNnz7Ro0SJrr712Hn744UqXBAAAAADAYmChD9GvvfbaDB06NMOGDcvjjz+elVdeOYMHD84777xT6dIAAAAAAFjELfQh+plnnpkf/vCH2XfffdO3b99ceOGFadWqVS699NJKlwYAAAAAwCJuoQ7Rp06dmsceeyyDBg0qtVVXV2fQoEF54IEHKlgZAAAAAACLg6aVLuCrvPfee5k+fXo6d+7coL1z5855/vnnZ7nOlClTMmXKlNLzCRMmJEkmTpw4/wqdhemffrRA9wcsfBb0+87C5uNPi0qXAFTYjAX8PjjzfbcovP/wzcx8DS3uv8sBABZ1c/oZYqEO0efGySefnOOOO65Re/fu3StQDbA4qz+80hUAVNih9RXZ7UcffZT6+srsm0XD+++/n8RnCACAxcXsPkMs1CH6EksskSZNmmTcuHEN2seNG5cuXbrMcp2jjjoqQ4cOLT2fMWNGPvjgg3To0CFVVVXztV6YaeLEienevXveeOON1NXVVbocgAXO+yCVUBRFPvroo3Tr1q3SpfAt1759+yTJ66+/7g8yZXifnz3naPaco9lzjmbPOZo952j2nKPZW1TP0Zx+hlioQ/TmzZtn9dVXz+jRozNkyJAkn4fio0ePziGHHDLLdWpqalJTU9OgrW3btvO5Upi1urq6ReqNBeDr8j7IgibwZF6orv781lH19fXew2bD+/zsOUez5xzNnnM0e87R7DlHs+cczd6ieI7m5DPEQh2iJ8nQoUOz9957Z4011shaa62Vs88+O5MmTcq+++5b6dIAAAAAAFjELfQh+i677JJ33303xxxzTMaOHZtVVlklt956a6ObjQIAAAAAwLy20IfoSXLIIYeUnb4FFkY1NTUZNmxYo6mFABYX3geBbzPvYbPnHM2eczR7ztHsOUez5xzNnnM0e87R7C3u56iqKIqi0kUAAAAAAMDCqLrSBQAAAAAAwMJKiA4AAAAAAGUI0WExdtlll6Vt27aVLgNYAHr27Jmzzz670mV863ifBAAAQIjOt8o+++yTqqqqVFVVpVmzZuncuXM233zzXHrppZkxY0aly1sgBDqw6Np4441z2GGHNWr3//3X43wB38SIESPSs2fPtGjRImuvvXYefvjhSpdUMSeffHLWXHPNtGnTJp06dcqQIUPywgsvNOiz8cYbl67PZz5+9KMfVajiBe/YY49tdPx9+vQpLZ88eXIOPvjgdOjQIbW1tdlxxx0zbty4Cla84PXs2bPROaqqqsrBBx+cZPF8Dd1zzz3Zdttt061bt1RVVeXGG29ssLwoihxzzDHp2rVrWrZsmUGDBuXFF19s0OeDDz7I7rvvnrq6urRt2zb77bdfPv744wV4FPPXV52jadOm5ec//3n69++f1q1bp1u3btlrr73y9ttvN9jGrF57v/71rxfwkcw/s3sdfTE/mfnYcsstG/RZnF9HSWb53lRVVZXTTjut1GdRfx3Nye/6Ofld9vrrr2frrbdOq1at0qlTp/zsZz/LZ599tiAPZb4TovOts+WWW2bMmDF59dVXc8stt2STTTbJT3/602yzzTaL3P+gAAAsONdee22GDh2aYcOG5fHHH8/KK6+cwYMH55133ql0aRVx99135+CDD86DDz6YUaNGZdq0adliiy0yadKkBv1++MMfZsyYMaXHqaeeWqGKK2OllVZqcPz33ntvadnhhx+ev/71r7nuuuty99135+23384OO+xQwWoXvEceeaTB+Rk1alSSZKeddir1WdxeQ5MmTcrKK6+cESNGzHL5qaeemnPOOScXXnhhHnroobRu3TqDBw/O5MmTS3123333/Pvf/86oUaNy880355577skBBxywoA5hvvuqc/TJJ5/k8ccfz9FHH53HH388119/fV544YVst912jfoOHz68wWvr0EMPXRDlLxCzex0l/5efzHxcffXVDZYvzq+jJA3OzZgxY3LppZemqqoqO+64Y4N+i/LraE5+18/ud9n06dOz9dZbZ+rUqbn//vtz+eWX57LLLssxxxxTiUOafwr4Ftl7772L7bffvlH76NGjiyTFxRdfXBRFUbz22mvFdtttV7Ru3bpo06ZNsdNOOxVjx45tsM5f/vKXYo011ihqamqKDh06FEOGDCktS1LccMMNDfrX19cXI0eOLIqiKF555ZUiSXHttdcWG2ywQdGiRYtijTXWKF544YXi4YcfLlZfffWidevWxZZbblm88847DbZz8cUXF3369ClqamqKFVZYoRgxYkRp2czt/vnPfy423njjomXLlsWAAQOK+++/vyiKorjzzjuLJA0ew4YNK4qiKCZPnlwcccQRRbdu3YpWrVoVa621VnHnnXc22PfIkSOL7t27Fy1btiyGDBlSnH766UV9ff0cnn1gfhs4cGDx05/+tFH7yJEjS/+vznwfPO2004ouXboU7du3L3784x8XU6dOLfUfN25csc022xQtWrQoevbsWVxxxRVFjx49irPOOqvUx/uk90mgsbXWWqs4+OCDS8+nT59edOvWrTj55JMrWNXC45133imSFHfffXeprdzvrsXFsGHDipVXXnmWy8aPH180a9asuO6660ptzz33XJGkeOCBBxZQhQufn/70p0Xv3r2LGTNmFEXhNfTla6oZM2YUXbp0KU477bRS2/jx44uampri6quvLoqiKJ599tkiSfHII4+U+txyyy1FVVVV8dZbby2w2heUWV13ftnDDz9cJClee+21UtuXr38XZbM6R+Xyk5m8jhrbfvvti0033bRB2+L0OiqKxr/r5+R32d///veiurq6wefJCy64oKirqyumTJmyYA9gPjISnUXCpptumpVXXjnXX///2rvzoCqrNw7gXwQvoAiKoOACKAiigjt0c5QxUEFSI1JAyiUlU4lcUMcU+RXu6WSToznl1rik5lZquCA6SqgTipAyCIi7oIOigSZweX5/OLz5CleplIvy/czcmXvPe97znvfO4bwvz3vuOTtQXl6OIUOG4M6dOzh69CgOHjyIixcvIiQkRMm/d+9eBAUFYeDAgThz5gwSEhLg5eX1j48bGxuL2bNn4/Tp0zAxMcHw4cMxffp0fP311zh27Biys7NVT942btyIOXPmYN68ecjIyMD8+fMRExOD9evXq8qdNWsWoqOjkZqaCldXV4SFhaGsrAxvvvkmli1bBktLS+UJaHR0NAAgMjISycnJ+PHHH5GWloahQ4fC399f+dnfyZMnMWbMGERGRiI1NRV9+/bF3Llz/83XTUQGlpiYiJycHCQmJipP+detW6dsHzVqFK5evYrExET89NNPWLFihWoUJftJ9pNEVFlJSQlSUlLg5+enpNWrVw9+fn5ITk42YM1qj3v37gEArK2tVekbN26EjY0NOnXqhJkzZ+LBgweGqJ7BZGVloUWLFmjbti3Cw8Nx5coVAEBKSgpKS0tVbap9+/ZwcHCos22qpKQEGzZswIcffggjIyMlva63oSfl5uYiLy9P1W6srKzg7e2ttJvk5GQ0btwYPXr0UPL4+fmhXr16OHnyZI3XuTa4d+8ejIyMKk3pt3DhQjRt2hRdu3bFl19+Wed+vX7kyBE0a9YMbm5uGD9+PAoKCpRtbEdq+fn52Lt3L8aMGVNpW11qR09f66tzLUtOToaHhweaN2+u5BkwYADu37+Pc+fO1WDtXzJDR/GJ/olnPUkNCQkRd3d3OXDggBgbG8uVK1eUbefOnRMAcurUKRER0Wq1Eh4ervc4qOYIy++//17ZvnnzZgEgCQkJStqCBQvEzc1N+ezs7CybNm1SlRsXFydarVZvuRV1z8jIEBH1iNQKly9fFmNj40pPi319fWXmzJkiIhIWFiYDBw5UbQ8JCeEIS6JapLoj0R0dHaWsrEzZPnToUAkJCRERkczMTFV/J/L3SIGKERTsJ//GfpKIKly/fl0AKL9sqTBt2jTx8vIyUK1qD51OJ4GBgdKrVy9V+qpVqyQ+Pl7S0tJkw4YN0rJlSwkKCjJQLWvevn37ZOvWrXL27FmJj48XrVYrDg4Ocv/+fdm4caNoNJpK+/Ts2VOmT59ugNoa3pYtWypdj+t6G3r6niopKUkAyI0bN1T5hg4dKsOGDRMRkXnz5omrq2ulsmxtbWXFihUvtb6GUNV955MePnwo3bp1k+HDh6vSly5dKomJiXL27FlZuXKlNG7cWCZPnvySa2sYVX1Hmzdvlt27d0taWprs3LlT3N3dpWfPnsr/EWxHaosWLZImTZrIw4cPVel1qR1Vda2vzrUsIiJC+vfvr9peXFwsAGTfvn0vt9I1yKRGI/ZEL5GIwMjICBkZGWjdujVat26tbOvQoQMaN26MjIwM9OzZE6mpqYiIiPjPx/T09FTeVzxx8/DwUKVVjP4sLi5GTk4OxowZozp2WVkZrKys9JZrb28PALh165ZqkaInpaenQ6fTwdXVVZX+6NEjNG3aFACQkZGBoKAg1XatVov4+PjqnSwR1RodO3aEsbGx8tne3h7p6ekAHv+tm5iYoHv37sr29u3bq0blsJ/8G/tJIqLqmThxIv744w/VfN8AVHPnenh4wN7eHr6+vsjJyYGzs3NNV7PGBQQEKO89PT3h7e0NR0dHbN26Febm5gasWe20evVqBAQEoEWLFkpaXW9D9N+UlpZi2LBhEBGsXLlStW3KlCnKe09PT2g0GowbNw4LFiyAqalpTVe1xoWGhirvPTw84OnpCWdnZxw5cgS+vr4GrFnttGbNGoSHh8PMzEyVXpfakb5rPT3GIDq9NjIyMtCmTZtq5X3eDa2RkRFERJVWWlpaKV/9+vVV+1SVVl5eDgDKCtffffcdvL29VeU8GQzTV25FOVUpKiqCsbExUlJSKpVlYWGhdz8iql0sLS2Vn889qbCwUBVEfrKPANR9zYvCfpKI6hobGxsYGxsjPz9flZ6fnw87OzsD1ap2iIyMVBaca9Wq1TPzVvTf2dnZdTIA2rhxY7i6uiI7Oxv9+vVDSUkJCgsLVQ+z62qbunz5Mg4dOoQdO3Y8M19db0MVbSM/P18ZKFDxuUuXLkqepxc8Lisrw507d+pU26oIoF++fBmHDx+GpaXlM/N7e3ujrKwMly5dgpubWw3VsvZo27YtbGxskJ2dDV9fX7ajJxw7dgyZmZnYsmXLc/O+ru1I37Xezs7uudcyOzs7nDp1SlVexf3U69SWOCc6vRYOHz6M9PR0BAcHw93dHVevXsXVq1eV7efPn0dhYSE6dOgA4PHTw4SEBL3l2dra4ubNm8rnrKys/zwvX/PmzdGiRQtcvHgRLi4uqld1g/8AoNFooNPpVGldu3aFTqfDrVu3KpVd0WG5u7tXmtfsxIkT/+mciOjFcnNzw+nTpyulnz59utIIan3at2+PsrIypKSkKGmZmZkoLCxUPrOfZD9JRJVpNBp0795d1feVl5cjISEBWq3WgDUzHBFBZGQkdu7cicOHD1erL05NTQUAVfCvLikqKkJOTg7s7e3RvXt31K9fX9WmMjMzceXKlTrZptauXYtmzZohMDDwmfnqehtq06YN7OzsVO3m/v37OHnypNJutFotCgsLVfd7hw8fRnl5eaWBCK+rigB6VlYWDh06pPyy8FlSU1NRr149NGvWrAZqWPtcu3YNBQUFyt8W29HfVq9eje7du6Nz587Pzfu6taPnXeurcy3TarVIT09XPZQ5ePAgLC0tlf8vXwcciU6vnEePHiEvLw86nQ75+fmIj4/HggUL8Pbbb2PEiBGoV68ePDw8EB4ejmXLlqGsrAwTJkyAj4+PsmBGbGwsfH194ezsjNDQUJSVlWHfvn2YMWMGgMcLlS5fvhxarRY6nQ4zZsyoNPLz3/j8888RFRUFKysr+Pv749GjR/j9999x9+5d1U+EnsXJyQlFRUVISEhA586d0aBBA7i6uiI8PBwjRozA0qVL0bVrV9y+fRsJCQnw9PREYGAgoqKi0KtXLyxZsgRDhgzB/v37OUUBUS0zfvx4LF++HFFRURg7dixMTU2xd+9ebN68Gb/88ku1ynBzc4O/vz/GjRuHlStXwsTEBJMmTVKNLPfz82M/yX6SiKowZcoUjBw5Ej169ICXlxeWLVuG4uJijB492tBVM4iJEydi06ZN2L17Nxo1aoS8vDwAjxc5NDc3R05ODjZt2oSBAweiadOmSEtLw+TJk9GnTx/VtFuvs+joaAwaNAiOjo64ceMGYmNjYWxsjLCwMFhZWWHMmDGYMmUKrK2tYWlpiU8++QRarRZvvPGGoateo8rLy7F27VqMHDkSJiZ/hyHqahsqKipCdna28jk3NxepqamwtraGg4MDJk2ahLlz56Jdu3Zo06YNYmJi0KJFC7zzzjsAHj/49/f3R0REBL799luUlpYiMjISoaGhqqlyXmXP+o7s7e3x3nvv4fTp09izZw90Op3SP1lbW0Oj0SA5ORknT55E37590ahRIyQnJ2Py5Ml4//330aRJE0Od1gv1rO/I2toan3/+OYKDg2FnZ4ecnBxMnz4dLi4uGDBgAAC2IwcHBwCPH1Jt27YNS5curbR/XWhHz7vWV+da1r9/f3To0AEffPABFi9ejLy8PMyePRsTJ058vaa8MeSE7ET/1MiRIwWAABATExOxtbUVPz8/WbNmjeh0OiXf5cuXZfDgwdKwYUNp1KiRDB06VPLy8lRlbd++Xbp06SIajUZsbGzk3XffVbZdv35d+vfvLw0bNpR27drJvn37qlww78yZM8o+iYmJAkDu3r2rpFW1uN3GjRuV4zZp0kT69OkjO3bs0Fvu3bt3BYAkJiYqaR9//LE0bdpUAEhsbKyIiJSUlMicOXPEyclJ6tevL/b29hIUFCRpaWnKfqtXr5ZWrVqJubm5DBo0SJYsWcIF84hqmVOnTkm/fv3E1tZWrKysxNvbW7UATlULLH/66afi4+OjfL5586YEBgaKqampODg4yA8//CCOjo7KwqIi7CfZTxKRPt988404ODiIRqMRLy8vOXHihKGrZDAV991Pvyr6+itXrkifPn3E2tpaTE1NxcXFRaZNmyb37t0zbMVrUEhIiNjb24tGo5GWLVtKSEiIZGdnK9sfPnwoEyZMkCZNmkiDBg0kKChIbt68acAaG8b+/fsFgGRmZqrS62obqrgnevo1cuRIEREpLy+XmJgYad68uZiamoqvr2+l766goEDCwsLEwsJCLC0tZfTo0fLnn38a4Gxejmd9RxX3g1W9Ku4HU1JSxNvbW6ysrMTMzEzc3d1l/vz58tdffxn2xF6gZ31HDx48kP79+4utra3Ur19fHB0dJSIiotL9fl1uRxVWrVol5ubmUlhYWGn/utCOnnetF6netezSpUsSEBAg5ubmYmNjI1OnTpXS0tIaPpuXy0jkqQlNiYiIiIiIiIiIiIgIAOdEJyIiIiIiIiIiIiLSi0F0IiIiIiIiIiIiIiI9GEQnIiIiIiIiIiIiItKDQXQiIiIiIiIiIiIiIj0YRCciIiIiIiIiIiIi0oNBdCIiIiIiIiIiIiIiPRhEJyIiIiIiIiIiIiLSg0F0IiIiIiIiIiIiIiI9GEQnIiIiIiIiIiIiItKDQXQiIiIiIiIiolfY7du3MX78eDg4OMDU1BR2dnYYMGAAkpKSDF01IqLXgomhK0BERERERERERP9ecHAwSkpKsH79erRt2xb5+flISEhAQUHBSzleSUkJNBrNSymbiKg24kh0IiIiIiIiIqJXVGFhIY4dO4ZFixahb9++cHR0hJeXF2bOnInBgwcrecaNG4fmzZvDzMwMnTp1wp49e5Qytm/fjo4dO8LU1BROTk5YunSp6hhOTk6Ii4vDiBEjYGlpiY8++ggAcPz4cfTu3Rvm5uZo3bo1oqKiUFxcXHMnT0RUQxhEJyIiIiIiIiJ6RVlYWMDCwgK7du3Co0ePKm0vLy9HQEAAkpKSsGHDBpw/fx4LFy6EsbExACAlJQXDhg1DaGgo0tPT8b///Q8xMTFYt26dqpwlS5agc+fOOHPmDGJiYpCTkwN/f38EBwcjLS0NW7ZswfHjxxEZGVkTp01EVKOMREQMXQkiIiIiIiIiIvp3tm/fjoiICDx8+BDdunWDj48PQkND4enpiQMHDiAgIAAZGRlwdXWttG94eDhu376NAwcOKGnTp0/H3r17ce7cOQCPR6J37doVO3fuVPKMHTsWxsbGWLVqlZJ2/Phx+Pj4oLi4GGZmZi/xjImIahZHohMRERERERERvcKCg4Nx48YN/Pzzz/D398eRI0fQrVs3rFu3DqmpqWjVqlWVAXQAyMjIQK9evVRpvXr1QlZWFnQ6nZLWo0cPVZ6zZ89i3bp1ykh4CwsLDBgwAOXl5cjNzX3xJ0lEZEBcWJSIiIiIiIiI6BVnZmaGfv36oV+/foiJicHYsWMRGxuL6OjoF1J+w4YNVZ+Lioowbtw4REVFVcrr4ODwQo5JRFRbMIhORERERERERPSa6dChA3bt2gVPT09cu3YNFy5cqHI0uru7O5KSklRpSUlJcHV1VeZNr0q3bt1w/vx5uLi4vPC6ExHVNpzOhYiIiIiIiIjoFVVQUIC33noLGzZsQFpaGnJzc7Ft2zYsXrwYQ4YMgY+PD/r06YPg4GAcPHgQubm5+PXXXxEfHw8AmDp1KhISEhAXF4cLFy5g/fr1WL58+XNHsM+YMQO//fYbIiMjkZqaiqysLOzevZsLixLRa4kj0YmIiIiIiIiIXlEWFhbw9vbGV199hZycHJSWlqJ169aIiIjAZ599BuDxwqPR0dEICwtDcXExXFxcsHDhQgCPR5Rv3boVc+bMQVxcHOzt7fHFF19g1KhRzzyup6cnjh49ilmzZqF3794QETg7OyMkJORlnzIRUY0zEhExdCWIiIiIiIiIiIiIiGojTudCRERERERERERERKQHg+hERERERERERERERHowiE5EREREREREREREpAeD6EREREREREREREREejCITkRERERERERERESkB4PoRERERERERERERER6MIhORERERERERERERKQHg+hERERERERERERERHowiE5EREREREREREREpAeD6EREREREREREREREejCITkRERERERERERESkB4PoRERERERERERERER6/B8baUyGW2ajRgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "🤖 AI INSIGHTS for datetime:\n",
            "📊 Complexity Score: 208.20\n",
            "📈 Total API Elements: 168\n",
            "📚 Documentation Coverage: 44.0%\n",
            "⚠️  Risk Factors:\n",
            "   • Large API surface - potential maintenance burden\n",
            "   • Poor documentation coverage\n",
            "\n",
            "⚖️  Comparing packages...\n",
            "🎯 Recommend os: Better complexity/documentation balance\n",
            "📊 Complexity comparison:\n",
            "   • datetime: 208.20\n",
            "   • os: 84.20\n",
            "\n",
            "🎉 Tutorial completed! This framework now:\n",
            "   • Handles analysis errors gracefully\n",
            "   • Falls back to simple module analysis when needed\n",
            "   • Provides meaningful insights for development decisions\n",
            "   • Works with both Griffe and basic Python introspection\n",
            "\n",
            "💡 For better results, try analyzing third-party packages like:\n",
            "   • requests, numpy, pandas, flask, django\n"
          ]
        }
      ],
      "source": [
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    }
  ]
}